Mover de um aplicativo da área de trabalho para uWP

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

Empacotar seu aplicativo da área de trabalho 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. MSIX é um formato de pacote do aplicativo do Windows moderno, 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 da área de trabalho do Windows em pacotes MSIX fornece a você acesso a uma experiência robusta de instalação e atualização, um modelo de segurança gerenciado com um sistema de capacidade flexível, suporte à Microsoft Store, gerenciamento empresarial e muitos modelos de distribuição personalizados. Você pode empacotar seu aplicativo se tiver o código-fonte ou se tiver apenas um arquivo instalador existente (como um instalador MSI ou App-V). 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 Criando um pacote MSIX com base em seu código e Recursos que exigem identidade do pacote.

Usar APIs de Windows Runtime

É possível chamar várias APIs do Windows Runtime diretamente no seu aplicativo da área de trabalho Win32 do WPF, do Windows Forms ou do C++ para integrar experiências modernas interessantes para usuários do Windows 10. Por exemplo, você pode chamar APIs do Windows Runtime para adicionar notificações do sistema ao seu aplicativo da área de trabalho.

Para saber mais, confira Usar APIs do Windows Runtime em aplicativos de área de trabalho.

Migrar um aplicativo .NET Framework para um aplicativo UWP

Se o 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 .NET 2.0 padrão

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. Contanto que seu código use APIs que são definidos no padrão, você pode reutilizá-los em um aplicativo UWP. É mais fácil do que nunca foi compartilhar código em uma biblioteca .NET padrão porque muitas APIs mais estão incluídas no .NET padrão 2.0.

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

Adicionar bibliotecas .NET Standard

Primeiro, adicione um ou mais bibliotecas de classe .NET Standard à sua solução.

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

Certifique-se de que cada biblioteca de classe do .NET Standard 2.0 tenha um destino.

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

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

Em seguida, use ferramentas para determinar quanto do seu código está em conformidade com o padrão. Dessa forma, antes de você 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 de biblioteca e código

Vamos começar com pacotes Nuget e outros arquivos dll que você obteve de terceiros.

Se seu aplicativo usa 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 ferramentas para analisar seu código. Baixe as ferramentas aqui (dotnet apiport) e, em seguida, assista a este vídeo para saber como usá-las.  

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

Parte de seu código será específica de plataforma e precisará permanecer em seu projeto de aplicativo da área de trabalho.

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

Vamos supor que temos um aplicativo de 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 SQLConnectionclasses , SqlCommande SqlDataReader e e 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 =
            @"Data Source=" +
            @"<Your Server Name>\SQLEXPRESS;Initial Catalog=NORTHWIND;Integrated Security=SSPI";

        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;
}

É possível usar o Navegador de API .NET para encontrar uma alternativa. Use as classes DbConnection, DbCommand e DbDataReader disponíveis no .NET Standard 2.0.

Essa versão revisada usa essas classes para obter uma lista de clientes, mas para criar uma classe DbConnection, será necessário 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 = @"Data Source=" +
                        @"<Your Server Name>\SQLEXPRESS;Initial Catalog=NORTHWIND;Integrated Security=SSPI";

        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 de code-behind do formulário Windows, podemos apenas criar a 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 precisará criar páginas de interface do usuário no XAML e escrever qualquer código específico do dispositivo ou da plataforma, mas quando terminar, poderá alcançar toda a amplitude dos dispositivos Windows 10 e Windows 11 e suas páginas de aplicativos 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 que não seja apenas um teclado e mouse, e recursos e configurações serão intuitivas em todos os dispositivos. Isso significa que os usuários aprendem a fazer as coisas uma vez e, em seguida, ele funciona de maneira bastante familiar, independentemente do dispositivo.

Essas são apenas algumas das novidades que vêm com UWP. Para saber mais, consulte Criar ótimas experiências com o Windows.

Adicionar um projeto UWP

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

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

Compilar suas páginas

Adicionar páginas XAML e chamar 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 com UWP, consulte O que é um aplicativo UWP.

Acessar dispositivos iOS e Android

Você pode entrar em dispositivos Android e iOS adicionando projetos Xamarin.

Observação

Para novos projetos multiplataforma, considere usar o MAUI do .NET.

Esses projetos permitem que você use C# para criar aplicativos Android e iOS com total acesso às APIs específicas de plataforma e específicas do dispositivo. Esses aplicativos aproveitam a aceleração de hardware específica de plataforma e são compiladas para desempenho nativo.

Eles têm acesso a toda gama de funcionalidade exposta pela plataforma e dispositivo, incluindo funcionalidades específicas de plataforma como iBeacons e fragmentos Android subjacentes, e você usará controles de interface do usuário nativo padrão para criar interfaces do usuário que fiquem do jeito que os usuários esperam que sejam.

Assim como UWPs, o custo para adicionar um aplicativo iOS ou Android é menor porque você pode reutilizar a lógica de negócios em uma biblioteca de classe .NET Standard 2.0. Você terá de projetar suas páginas da interface do usuário em XAML e escrever qualquer dispositivo ou o código específico de plataforma.

Adicionar um projeto Xamarin

Primeiro, adicione um projeto Android, iOS, ou Plataforma cruzada à sua solução.

Você pode encontrar esses modelos na caixa de diálogo Adicionar novo projeto no grupo Visual C#.

Observação

Projetos de plataforma cruzada são ótimos para aplicativos com pouca funcionalidade específica de plataforma. Você pode usá-los para criar uma IU baseada em XAML nativa que roda em iOS, Android e Windows. Saiba mais aqui.

Em seguida, do Android, iOS ou do projeto de plataforma cruzada, adicione uma referência do projeto de biblioteca de classe.

Compilar suas páginas

Nosso exemplo mostra uma lista de clientes em um aplicativo do Android.

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:padding="10dp" android:textSize="16sp"
    android:id="@android:id/list">
</TextView>

[Activity(Label = "MyAndroidApp", MainLauncher = true)]
public class MainActivity : ListActivity
{
    protected override void OnCreate(Bundle savedInstanceState)
    {
        base.OnCreate(savedInstanceState);

        SqlClientFactory factory = SqlClientFactory.Instance;

        var customers = (string[])Northwind.GetCustomerNames(factory).ToArray(typeof(string));

        ListAdapter = new ArrayAdapter<string>(this, Resource.Layout.list_item, customers);
    }
}

Para começar com Android, iOS e projetos de plataforma cruzada, consulte o Portal do desenvolvedor Xamarin.

Próximas etapas

Encontre respostas para suas dúvidas

Tem dúvidas? Pergunte-nos no Stack Overflow. Nossa equipe monitora estas marcas. Você também pode entrar em contato conosco aqui.