Como atualizar um aplicativo de área de trabalho WPF para .NET 8

Artigo
02/08/2024

Este artigo descreve como atualizar um aplicativo de área de trabalho do Windows Presentation Foundation (WPF) para o .NET 8. Mesmo que o WPF seja executado em .NET, uma tecnologia multiplataforma, o WPF ainda é uma estrutura somente para Windows. Os seguintes tipos de projeto relacionados ao WPF podem ser atualizados com o Assistente de Atualização do .NET:

Projeto WPF
Biblioteca de controle
Biblioteca .NET

Se você estiver atualizando do .NET Framework para o .NET, considere revisar o artigo Diferenças com o WPF .NET e o guia Portando do .NET Framework para o .NET .

Pré-requisitos

Aplicativo de demonstração

Este artigo foi escrito no contexto da atualização do projeto Web Favorites Sample, que você pode baixar do repositório GitHub de exemplos do .NET.

Iniciar a atualização

Se você estiver atualizando vários projetos, comece com projetos que não têm dependências. No exemplo de Favoritos da Web, o projeto WebSiteRatings depende da biblioteca StarVoteControl, portanto, StarVoteControl deve ser atualizado primeiro.

Dica

Certifique-se de ter um backup do seu código, como no controle do código-fonte ou em uma cópia.

Use as seguintes etapas para atualizar um projeto no Visual Studio:

Clique com o botão direito do mouse no projeto StarVoteControl na janela Gerenciador de Soluções e selecione Atualizar:

Uma nova guia é aberta solicitando que você escolha como deseja que a atualização seja executada.
Selecione Atualização de projeto in-loco.
Em seguida, selecione a estrutura de destino. Com base no tipo de projeto que você está atualizando, diferentes opções são apresentadas. O .NET Standard 2.0 é uma boa opção se a biblioteca não depender de uma tecnologia de área de trabalho como o WPF e puder ser usada por projetos do .NET Framework e projetos do .NET. No entanto, as versões mais recentes do .NET fornecem muitos aprimoramentos de linguagem e compilador em relação ao .NET Standard.

Selecione .NET 8.0 e, em seguida, selecione Avançar.
Uma árvore é mostrada com todos os artefatos relacionados ao projeto, como arquivos de código e bibliotecas. Você pode atualizar artefatos individuais ou o projeto inteiro, que é o padrão. Selecione Seleção de atualização para iniciar a atualização.

Quando a atualização for concluída, os resultados serão exibidos:

Artefatos com um círculo verde sólido foram atualizados, enquanto círculos verdes vazios foram ignorados. Artefatos ignorados significam que o assistente de atualização não encontrou nada para atualizar.

Agora que a biblioteca de suporte do aplicativo foi atualizada, atualize o aplicativo principal.

Upgrade do aplicativo

Depois que todas as bibliotecas de suporte forem atualizadas, o projeto de aplicativo principal poderá ser atualizado. Execute as etapas a seguir:

Clique com o botão direito do mouse no projeto WebSiteRatings na janela Gerenciador de Soluções e selecione Atualizar:
Selecione Atualização de projeto in-loco como o modo de atualização.
Selecione .NET 8.0 para a estrutura de destino e selecione Avançar.
Deixe todos os artefatos selecionados e selecione Atualizar seleção.

Após a conclusão da atualização, os resultados são mostrados. Se um item tiver um símbolo de aviso, isso significa que há uma nota para você ler, o que você pode fazer expandindo o item.

Gerar uma compilação limpa

Depois que seu projeto for atualizado, limpe-o e compile-o.

Clique com o botão direito do mouse no projeto WebSiteRatings na janela Gerenciador de Soluções e selecione Limpar.
Clique com o botão direito do mouse no projeto WebSiteRatings na janela Gerenciador de Soluções e selecione Compilar.

Se seu aplicativo encontrou erros, você pode encontrá-los na janela Lista de erros com uma recomendação de como corrigi-los.

Etapas de pós-atualização

Se o seu projeto estiver sendo atualizado do .NET Framework para o .NET, revise as informações no artigo Modernizar após a atualização para o .NET do .NET Framework .

Após a atualização, você deverá:

Verifique seus pacotes NuGet.

O Assistente de Atualização do .NET atualizou alguns pacotes para novas versões. Com o aplicativo de exemplo fornecido neste artigo, o Microsoft.Data.Sqlite pacote NuGet foi atualizado de 1.0.0 para 8.0.x. No entanto, 1.0.0 depende do SQLite pacote NuGet, mas 8.0.x remove essa dependência. O SQLite pacote NuGet ainda é referenciado pelo projeto, embora não seja mais necessário. Os pacotes NuGet e SQLite.Native NuGet SQLite podem ser removidos do projeto.
Limpe os pacotes NuGet antigos.

O arquivo packages.config não é mais necessário e pode ser excluído do seu projeto, pois as referências do pacote NuGet agora são declaradas no arquivo de projeto. Além disso, a pasta de cache de pacote NuGet local, chamada Pacotes, está na pasta ou na pasta pai do projeto. Essa pasta de cache local pode ser excluída. As novas referências de pacote NuGet usam uma pasta de cache global para pacotes, disponível no diretório de perfil do usuário, chamada .nuget\packages.
Remova a System.Configuration biblioteca.

A maioria dos aplicativos do .NET Framework faz referência à System.Configuration biblioteca. Após a atualização, é possível que essa biblioteca ainda seja referenciada diretamente.

A System.Configuration biblioteca usa o arquivo app.config para fornecer opções de configuração em tempo de execução para seu aplicativo. Para o .NET, essa biblioteca foi substituída System.Configuration.ConfigurationManager pelo pacote NuGet. Remova a referência à biblioteca e adicione o pacote NuGet ao seu projeto.
Verifique se há locais para modernizar seu aplicativo.

APIs e bibliotecas mudaram bastante desde que o .NET foi lançado. E, na maioria dos casos, o .NET Framework não tem acesso a essas melhorias. Ao atualizar para o .NET, agora você tem acesso a bibliotecas mais modernas.

As próximas seções descrevem as áreas que você moderniza o aplicativo de exemplo usado por este artigo.

Modernizar: controle do navegador da Web

O WebBrowser controle referenciado pelo aplicativo de exemplo WPF é baseado no Internet Explorer, que está desatualizado. WPF para .NET pode usar o controle WebView2 com base no Microsoft Edge. Conclua as seguintes etapas para atualizar para o novo controle WebView2 do navegador da Web:

Adicione o pacote NuGet Microsoft.Web.WebView2.

No arquivo MainWindow.xaml:

Importe o controle para o namespace wpfControls no elemento raiz:

<mah:MetroWindow x:Class="WebSiteRatings.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:mah="clr-namespace:MahApps.Metro.Controls;assembly=MahApps.Metro"
        xmlns:local="clr-namespace:WebSiteRatings"
        xmlns:vm="clr-namespace:WebSiteRatings.ViewModels"
        xmlns:VoteControl="clr-namespace:StarVoteControl;assembly=StarVoteControl"
        xmlns:wpfControls="clr-namespace:Microsoft.Web.WebView2.Wpf;assembly=Microsoft.Web.WebView2.Wpf"
        Loaded="MetroWindow_Loaded"
        mc:Ignorable="d"
        Title="My Sites" Height="650" Width="1000">

Abaixo, onde o elemento <Border> é declarado, remova o controle WebBrowser e substitua-o pelo controle wpfControls:WebView2:

<Border Grid.Row="2" Grid.Column="1" Grid.ColumnSpan="2" BorderThickness="1" BorderBrush="Black" Margin="5">
    <wpfControls:WebView2 x:Name="browser" ScrollViewer.CanContentScroll="True" />
</Border>

Edite o arquivo code-behind MainWindow.xaml.cs. Atualize o método ListBox_SelectionChanged para definir a propriedade browser.Source como um Uri válido. Esse código era passado anteriormente na URL do site como uma cadeia de caracteres, mas o controle WebView2 requer um Uri.

private void ListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
    var siteCollection = (ViewModels.SiteCollection)DataContext;

    if (siteCollection.SelectedSite != null)
        browser.Source = new Uri(siteCollection.SelectedSite.Url);
    else
        browser.NavigateToString("<body></body>");
}

Dependendo da versão do Windows que o usuário do aplicativo está executando, pode ser necessário instalar o runtime WebView2. Para obter mais informações, confira Introdução ao WebView2 em aplicativos WPF.

Modernizar: appsettings.json

O .NET Framework usa o arquivo App.config para carregar configurações do aplicativo, como cadeias de conexão e provedores de log. O .NET agora usa o arquivo appsettings.json para configurações de aplicativo. Os arquivos App.config são compatíveis com o .NET por meio do pacote NuGet System.Configuration.ConfigurationManager e o suporte para appsettings.json é fornecido pelo pacote NuGet Microsoft.Extensions.Configuration.

À medida que outras bibliotecas forem atualizadas para o .NET, elas serão modernizadas com o suporte ao appsettings.json em vez de App.config. Por exemplo, os provedores de log no .NET Framework que foram atualizados para o .NET 6 e versões posteriores não usam mais o App.config para configurações. É bom seguir sua direção e também se afastar do uso do App.config onde puder.

Usar appsettings.json com o aplicativo de exemplo do WPF

Por exemplo, depois de atualizar o aplicativo de exemplo WPF, use appsettings.json para a cadeia de conexão com o banco de dados local.

Remova o pacote NuGet System.Configuration.ConfigurationManager.
Adicione o pacote NuGet Microsoft.Extensions.Configuration.Json.
Adicione um arquivo ao projeto chamado appsettings.json.
Defina o arquivo appsettings.json para copiar no diretório de saída.

Defina a configuração de cópia para saída por meio do Visual Studio usando a janela Propriedades depois de selecionar o arquivo no Gerenciador de Soluções. Como alternativa, você pode editar o projeto diretamente e adicionar o seguinte ItemGroup:
```
  <ItemGroup>
    <Content Include="appsettings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </Content>
  </ItemGroup>
```
Migre as configurações no arquivo App.config para um novo arquivo appsettings.json .

No aplicativo de exemplo WPF, app.config continha apenas uma única cadeia de conexão. Edite o arquivo appsettings.json para definir a cadeia de conexão:
```
{
  "ConnectionStrings": {
    "database": "DataSource=sqlite.db;"
  }
}
```

Edite o arquivo App.xaml.cs, instanciando um objeto de configuração que carrega o arquivo appsettings.json, as linhas adicionadas são realçadas:

using System.Windows;
using Microsoft.Extensions.Configuration;

namespace WebSiteRatings
{
    /// <summary>
    /// Interaction logic for App.xaml
    /// </summary>
    public partial class App : Application
    {
        public static IConfiguration Config { get; private set; }

        public App()
        {
            Config = new ConfigurationBuilder()
                .AddJsonFile("appsettings.json")
                .Build();
        }
    }
}

No arquivo .\Models\Database.cs, altere o método OpenConnection para usar a nova propriedade App.Config. Isso requer a importação do namespace Microsoft.Extensions.Configuration:

using Microsoft.Data.Sqlite;
using System.Collections.Generic;
using Microsoft.Extensions.Configuration;

namespace WebSiteRatings.Models
{
    internal class Database
    {
        public static SqliteConnection OpenConnection() =>
            new SqliteConnection(App.Config.GetConnectionString("database"));

        public static IEnumerable<Site> ReadSites()

GetConnectionString é um método de extensão fornecido pelo namespace Microsoft.Extensions.Configuration.