Use o .NET Generic Host numa aplicação Windows Forms

O .NET Generic Host fornece uma forma padronizada de configurar e executar aplicações com suporte incorporado para injeção de dependências (DI), configuração e log. As aplicações do Windows Forms não incluem integração com o Generic Host por defeito, mas podes adicioná-la. Este artigo mostra como configurar o Host Genérico numa aplicação Windows Forms para injetar serviços nos seus formulários.

Pré-requisitos

• O pacote NuGet Microsoft.Extensions.Hosting.

Configurar o Host Genérico

A configuração difere ligeiramente entre C# e Visual Basic. Em C#, configure o host diretamente em Program.cs. No Visual Basic, utilize os eventos de arranque e desligamento do Application Framework em ApplicationEvents.vb.

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace HostBuilderApp;

static class Program
{
    [STAThread]
    static void Main()
    {
        ApplicationConfiguration.Initialize();

        var builder = Host.CreateApplicationBuilder();

        builder.Services.AddHostedService<SampleLifecycleService>();
        builder.Services.AddTransient<Form1>();
        builder.Services.AddSingleton<IGreetingService, GreetingService>();

        IHost host = builder.Build();

        host.Start();

        Form1 mainForm = host.Services.GetRequiredService<Form1>();
        Application.Run(mainForm);

        host.StopAsync().GetAwaiter().GetResult();
        host.Dispose();
    }
}

Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Hosting

Namespace My

    Partial Friend Class MyApplication

        Private Shared _host As IHost

        ' Build and start the host when the application starts.
        Private Sub MyApplication_Startup(sender As Object, e As Microsoft.VisualBasic.ApplicationServices.StartupEventArgs) Handles Me.Startup
            Dim builder = Host.CreateApplicationBuilder()

            builder.Services.AddHostedService(Of SampleLifecycleService)()
            builder.Services.AddTransient(Of Form1)()
            builder.Services.AddSingleton(Of IGreetingService, GreetingService)()

            _host = builder.Build()

            _host.Start()
        End Sub

        ' Stop and dispose of the host when the application shuts down.
        Private Sub MyApplication_Shutdown(sender As Object, e As EventArgs) Handles Me.Shutdown
            _host.StopAsync().GetAwaiter().GetResult()
            _host.Dispose()
        End Sub

        ' Resolve the main form from DI instead of using the default form instance.
        Protected Overrides Sub OnCreateMainForm()
            Me.MainForm = _host.Services.GetRequiredService(Of Form1)()
        End Sub

        ' Expose the host so forms can resolve services via HostInstance.Services.
        Friend Shared ReadOnly Property HostInstance As IHost
            Get
                Return _host
            End Get
        End Property

    End Class

End Namespace

Private _host As IHost

<STAThread()>
Friend Sub Main(args As String())
    ' Configure the host with services
    Dim builder = Host.CreateApplicationBuilder(args)

    builder.Services.AddHostedService(Of SampleLifecycleService)()
    builder.Services.AddTransient(Of Form1)()
    builder.Services.AddSingleton(Of IGreetingService, GreetingService)()

    _host = builder.Build()
    _host.Start()

    ' Run the application with the main form resolved from the host
    Application.SetHighDpiMode(HighDpiMode.SystemAware)
    Application.EnableVisualStyles()
    Application.SetCompatibleTextRenderingDefault(False)
    Application.Run(_host.Services.GetRequiredService(Of Form1)())

    ' Stop the host when the application exits
    _host.StopAsync().GetAwaiter().GetResult()
    _host.Dispose()
End Sub

Friend ReadOnly Property HostInstance As IHost
    Get
        Return _host
    End Get
End Property

Registar e consumir serviços

Com o host configurado, regista serviços personalizados e injeta-os nos teus formulários. Para criar e registar um serviço:

1. Defina uma interface de serviço:

   public interface IGreetingService
   {
       string GetGreeting();
   }
   

   Public Interface IGreetingService
       Function GetGreeting() As String
   End Interface
   

2. Crie uma classe que implemente a interface. A GreetingService classe injeta IConfiguration para ler a mensagem de saudação de appsettings.json:

   public class GreetingService : IGreetingService
   {
       private readonly IConfiguration _configuration;
   
       public GreetingService(IConfiguration configuration)
       {
           _configuration = configuration;
       }
   
       public string GetGreeting()
       {
           return _configuration.GetValue<string>("GreetingMessage")
               ?? "Hello, World!";
       }
   }
   

   Public Class GreetingService
       Implements IGreetingService
   
       Private ReadOnly _configuration As IConfiguration
   
       Public Sub New(configuration As IConfiguration)
           _configuration = configuration
       End Sub
   
       Public Function GetGreeting() As String Implements IGreetingService.GetGreeting
           Dim message As String = _configuration.GetValue(Of String)("GreetingMessage")
   
           If message Is Nothing Then
               Return "Hello, World!"
           End If
   
           Return message
       End Function
   
   End Class
   

3. Registe o interface e a implementação na propriedade Services do construtor, como mostrado na secção Configurar o Host Genérico.

Gerir um serviço alojado

O Host Genérico também pode executar serviços em segundo plano que participam no ciclo de vida da aplicação. Implemente IHostedService para receber callbacks quando o host arranca e pára. Para adicionar um serviço alojado:

1. Crie uma classe que implemente o IHostedService. A seguinte classe escreve na saída de depuração quando o host inicia e para:

   public class SampleLifecycleService : IHostedService
   {
       public Task StartAsync(CancellationToken cancellationToken)
       {
           System.Diagnostics.Debug.WriteLine("SampleLifecycleService: Started.");
           return Task.CompletedTask;
       }
   
       public Task StopAsync(CancellationToken cancellationToken)
       {
           System.Diagnostics.Debug.WriteLine("SampleLifecycleService: Stopped.");
           return Task.CompletedTask;
       }
   }
   

   Public Class SampleLifecycleService
       Implements IHostedService
   
       Public Function StartAsync(cancellationToken As CancellationToken) As Task Implements IHostedService.StartAsync
           System.Diagnostics.Debug.WriteLine("SampleLifecycleService: Started.")
           Return Task.CompletedTask
       End Function
   
       Public Function StopAsync(cancellationToken As CancellationToken) As Task Implements IHostedService.StopAsync
           System.Diagnostics.Debug.WriteLine("SampleLifecycleService: Stopped.")
           Return Task.CompletedTask
       End Function
   
   End Class
   

2. Registe o serviço na AddHostedService propriedade do Services construtor, como mostrado na secção Configurar o Host Genérico .

O host chama StartAsync no arranque e StopAsync ao encerrar, por isso o output de depuração aparece na janela Output no Visual Studio.

Consumir serviços numa forma

Como Form1 é resolvido a partir do contentor DI, a injeção do construtor funciona diretamente:

1. Adicione parâmetros de construtor para cada serviço que o formulário necessita.
2. Armazene os serviços injetados em campos privados.
3. Utilize os serviços em manipuladores de eventos ou outros métodos.

public partial class Form1 : Form
{
    private readonly ILogger<Form1> _logger;
    private readonly IGreetingService _greetingService;

    public Form1(ILogger<Form1> logger, IGreetingService greetingService)
    {
        InitializeComponent();

        _logger = logger;
        _greetingService = greetingService;
    }

    private void ButtonGreet_Click(object sender, EventArgs e)
    {
        string greeting = _greetingService.GetGreeting();
        lblGreeting.Text = greeting;
        _logger.LogInformation("Greeting displayed: {Greeting}", greeting);
    }
}

Public Class Form1

    Private _logger As ILogger(Of Form1)
    Private _greetingService As IGreetingService

    Sub New(ILogger As ILogger(Of Form1), greetingService As IGreetingService)
        InitializeComponent()
        _logger = ILogger
        _greetingService = greetingService
    End Sub

    Private Sub ButtonGreet_Click(sender As Object, e As EventArgs) Handles btnGreet.Click
        Dim greeting As String = _greetingService.GetGreeting()
        lblGreeting.Text = greeting
        _logger.LogInformation("Greeting displayed: {Greeting}", greeting)
    End Sub

End Class

Adicionar configuração

CreateApplicationBuilder carrega appsettings.json automaticamente a partir do diretório de saída. Para adicionar um ficheiro de configuração:

1. Crie um appsettings.json ficheiro na raiz do projeto com os seus valores de configuração:

   {
     "GreetingMessage": "Hello from the Generic Host!"
   }
   

2. Definido CopyToOutputDirectory como PreserveNewest no ficheiro do projeto para appsettings.json que seja copiado para o diretório de saída:

   <Project Sdk="Microsoft.NET.Sdk">
   
     <PropertyGroup>
       <OutputType>WinExe</OutputType>
       <TargetFramework>net10.0-windows</TargetFramework>
       <Nullable>enable</Nullable>
       <ImplicitUsings>enable</ImplicitUsings>
       <UseWindowsForms>true</UseWindowsForms>
     </PropertyGroup>
   
     <ItemGroup>
       <None Update="appsettings.json">
         <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
       </None>
     </ItemGroup>
   
     <ItemGroup>
       <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.*" />
     </ItemGroup>
   
   </Project>
   

Conteúdo relacionado

• Injeção de dependência no .NET
• Host Genérico .NET
• Registo em .NET
• Configuração em .NET