Passar de um aplicativo de desktop para a Plataforma Universal do Windows (UWP)

Se você tiver um aplicativo de área de trabalho existente criado usando o .NET Framework (incluindo WPF e Windows Forms) ou APIs do C++ Win32, você terá várias opções para migrar para a Plataforma Universal do Windows (UWP) e o Windows 10/11.

Empacote seu aplicativo desktop em um pacote MSIX

Você pode empacotar seu aplicativo da área de trabalho em um pacote MSIX para obter acesso a muitos outros recursos do Windows 10 e windows 11. O MSIX é um formato de pacote de aplicativo moderno do Windows que fornece uma experiência de empacotamento universal para todos os aplicativos do Windows, incluindo aplicativos UWP, WPF, Windows Forms e Win32. Empacotar seus aplicativos do Windows da área de trabalho em pacotes MSIX lhe dá acesso a uma experiência robusta de instalação e atualização, um modelo de segurança gerenciado com um sistema de funcionalidade flexível, suporte para a Microsoft Store, gerenciamento corporativo e muitos modelos de distribuição personalizados. Você pode empacotar seu aplicativo se tiver o código-fonte ou se tiver apenas um arquivo de instalador existente (como uma MSI ou App-V instalador). Depois de empacotar seu aplicativo, você pode integrar recursos UWP, como extensões de pacote e outros componentes UWP.

Para obter mais informações, consulte Como criar um pacote MSIX a partir do seu código e Recursos que exigem identidade do pacote.

Usar APIs do Windows Runtime

Você pode chamar muitas das APIs do Windows Runtime diretamente no seu aplicativo de desktop WPF, Windows Forms ou C++ Win32 para integrar experiências modernas que aprimoram a interação dos usuários do Windows 10. Por exemplo, você pode chamar APIs do Windows Runtime para adicionar notificações do tipo 'toast' ao seu aplicativo da área de trabalho.

Para obter mais informações, consulte Usar APIs do Windows Runtime em aplicativos da área de trabalho.

Migrar um aplicativo .NET Framework para um aplicativo UWP

Se seu aplicativo for executado no .NET Framework, você poderá migrá-lo para um aplicativo UWP aproveitando o .NET Standard 2.0. Mova o máximo de código possível para bibliotecas de classes do .NET Standard 2.0 e crie um aplicativo UWP que faça referência às bibliotecas do .NET Standard 2.0.

Compartilhar código em uma biblioteca do .NET Standard 2.0

Se o aplicativo for executado no .NET Framework, coloque o máximo de código possível nas bibliotecas de classes do .NET Standard 2.0. Desde que seu código use APIs definidas no padrão, você poderá reutilizá-lo em um aplicativo UWP. É mais fácil do que nunca compartilhar código em uma biblioteca do .NET Standard porque muitas outras APIs estão incluídas no .NET Standard 2.0.

Assista a um vídeo que explica mais sobre isso.

Adicionar bibliotecas do .NET Standard

Primeiro, adicione uma ou mais bibliotecas de classes do .NET Standard à sua solução.

O número de bibliotecas que você adiciona à sua solução depende de como você planeja organizar seu código.

Verifique se cada biblioteca de classes tem como destino o .NET Standard 2.0.

Você pode encontrar essa configuração nas páginas de propriedades do projeto da biblioteca de classes.

No projeto de aplicativo da área de trabalho, adicione uma referência ao projeto de biblioteca de classes.

Em seguida, use ferramentas para determinar quanto do código está em conformidade com o padrão. Dessa forma, antes de mover o código para a biblioteca, você pode decidir quais partes você pode reutilizar, quais partes exigem modificação mínima e quais partes permanecerão específicas do aplicativo.

Verificar a compatibilidade entre a biblioteca e o código

Começaremos com pacotes Nuget e outros arquivos dll obtidos de terceiros.

Se o aplicativo usar qualquer um deles, determine se eles são compatíveis com o .NET Standard 2.0. Você pode usar uma extensão do Visual Studio ou um utilitário de linha de comando para fazer isso.

Use essas mesmas ferramentas para analisar seu código. Baixe as ferramentas aqui (dotnet-apiport) e assista a este vídeo para saber como usá-las.  

Se o código não for compatível com o padrão, considere outras maneiras de implementar esse código. Comece abrindo o Navegador de API do .NET. Você pode usar esse navegador para examinar as API que estão disponíveis no .NET Standard 2.0. Certifique-se de definir o escopo da lista para o .NET Standard 2.0.

Parte do seu código será específico para a plataforma e precisará permanecer no projeto de aplicação de desktop.

Exemplo: migrando o código de acesso a dados para uma biblioteca do .NET Standard 2.0

Vamos supor que temos um aplicativo Windows Forms muito básico que mostra os clientes do nosso banco de dados de exemplo Northwind.

O projeto contém uma biblioteca de classes do .NET Standard 2.0 com uma classe estática chamada Northwind. Se movermos esse código para a classe Northwind, ele não será compilado porque ele usa as SQLConnectionSqlCommandclasses e SqlDataReader as classes que não estão disponíveis no .NET Standard 2.0.

public static ArrayList GetCustomerNames()
{
    ArrayList customers = new ArrayList();

    using (SqlConnection conn = new SqlConnection())
    {
        conn.ConnectionString = ...; // Your connection string goes here.

        conn.Open();

        SqlCommand command = new SqlCommand("select ContactName from customers order by ContactName asc", conn);

        using (SqlDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                customers.Add(reader[0]);
            }
        }
    }

    return customers;
}

No entanto, podemos usar o do Navegador de API do .NET para encontrar uma alternativa. As DbConnectionclasses , DbCommande DbDataReader , estão todas disponíveis no .NET Standard 2.0 para que possamos usá-las em vez disso.

Essa versão revisada usa essas classes para obter uma lista de clientes, mas para criar uma DbConnection classe, precisaremos passar um objeto de fábrica que criamos no aplicativo cliente.

public static ArrayList GetCustomerNames(DbProviderFactory factory)
{
    ArrayList customers = new ArrayList();

    using (DbConnection conn = factory.CreateConnection())
    {
        conn.ConnectionString = ...; // Your connection string goes here.

        conn.Open();

        DbCommand command = factory.CreateCommand();
        command.Connection = conn;
        command.CommandText = "select ContactName from customers order by ContactName asc";

        using (DbDataReader reader = command.ExecuteReader())
        {
            while (reader.Read())
            {
                customers.Add(reader[0]);
            }
        }
    }

    return customers;
}

Na página code-behind do Windows Form, podemos simplesmente criar uma instância de fábrica e passá-la para nosso método.

public partial class Customers : Form
{
    public Customers()
    {
        InitializeComponent();

        dataGridView1.Rows.Clear();

        SqlClientFactory factory = SqlClientFactory.Instance;

        foreach (string customer in Northwind.GetCustomerNames(factory))
        {
            dataGridView1.Rows.Add(customer);
        }
    }
}

Criar um aplicativo UWP

Agora você está pronto para adicionar um aplicativo UWP à sua solução.

Você ainda terá que criar páginas de interface do usuário em XAML e escrever qualquer código específico do dispositivo ou da plataforma, mas quando terminar, você poderá alcançar toda a amplitude dos dispositivos Windows 10 e Windows 11 e suas páginas de aplicativo terão uma sensação moderna que se adapta bem a diferentes tamanhos e resoluções de tela.

Seu aplicativo responderá a mecanismos de entrada diferentes de apenas um teclado e mouse, e recursos e configurações serão intuitivos entre dispositivos. Isso significa que os usuários aprendem a fazer as coisas uma vez e, em seguida, ele funciona de uma maneira muito familiar, não importa o dispositivo.

Estas são apenas algumas das guloseimas que vêm com a UWP. Para saber mais, consulte Crie ótimas experiências com o Windows.

Adicionar um projeto UWP

Primeiro, adicione um projeto UWP à sua solução.

Em seguida, no projeto UWP, adicione uma referência ao projeto de biblioteca do .NET Standard 2.0.

Construa suas páginas

Adicione páginas XAML e chame o código em sua biblioteca .NET Standard 2.0.

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <StackPanel x:Name="customerStackPanel">
        <ListView x:Name="customerList"/>
    </StackPanel>
</Grid>

public sealed partial class MainPage : Page
{
    public MainPage()
    {
        this.InitializeComponent();

        SqlClientFactory factory = SqlClientFactory.Instance;

        customerList.ItemsSource = Northwind.GetCustomerNames(factory);
    }
}

Para começar a usar a UWP, consulte o que é um aplicativo UWP.

Próximas etapas

Encontrar respostas para suas perguntas

Tem dúvidas? Pergunte-nos sobre o Stack Overflow. Nossa equipe monitora essas tags . Você também pode nos perguntar aqui .