Korzystanie z hosta ogólnego platformy .NET w aplikacji Windows Forms

Host ogólny platformy .NET zapewnia ustandaryzowany sposób konfigurowania i uruchamiania aplikacji z wbudowaną obsługą wstrzykiwania zależności (DI), konfiguracji i rejestrowania. Aplikacje Windows Forms nie obejmują domyślnie integracji z hostem ogólnym, ale można je dodać. W tym artykule przedstawiono sposób konfigurowania hosta ogólnego w aplikacji Windows Forms w celu wstrzykiwania usług do formularzy.

Wymagania wstępne

• Microsoft.Extensions.Hosting Pakiet NuGet.

Konfigurowanie hosta ogólnego

Konfiguracja różni się nieco między językami C# i Visual Basic. W języku C#skonfiguruj hosta bezpośrednio w programie Program.cs. W języku Visual Basic użyj zdarzeń uruchamiania i zamykania struktury aplikacji w programie 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

Rejestrowanie i korzystanie z usług

Po skonfigurowaniu hosta zarejestruj usługi niestandardowe i wprowadź je do formularzy. Aby utworzyć i zarejestrować usługę:

1. Definiowanie interfejsu usługi:

   public interface IGreetingService
   {
       string GetGreeting();
   }
   

   Public Interface IGreetingService
       Function GetGreeting() As String
   End Interface
   

2. Utwórz klasę, która implementuje interfejs. Klasa GreetingService wstrzykuje IConfiguration do odczytania wiadomości powitalnej z 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. Zarejestruj interfejs i implementację we właściwości buildera Services, jak pokazano w sekcji Konfigurowanie hosta generycznego.

Uruchamianie hostowanej usługi

Host ogólny może również uruchamiać usługi w tle, które uczestniczą w cyklu życia aplikacji. Zaimplementuj IHostedService, aby odbierać wywołania zwrotne po uruchomieniu i zatrzymaniu hosta. Aby dodać hostowaną usługę:

1. Utwórz klasę, która implementuje IHostedService. Następująca klasa zapisuje dane wyjściowe debugowania po uruchomieniu i zatrzymaniu hosta:

   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. Zarejestruj usługę AddHostedService w właściwości projektanta Services, jak pokazano w sekcji Konfigurowanie hosta ogólnego.

Host wywołuje StartAsync na uruchomienie i StopAsync na zamknięcie, więc dane wyjściowe debugowania są wyświetlane w oknie Dane wyjściowe w programie Visual Studio.

Korzystanie z usług w określonej formie

Ponieważ Form1 jest rozpoznawany z kontenera DI, wstrzykiwanie konstruktora działa bezpośrednio:

1. Dodaj parametry konstruktora dla każdej usługi, których potrzebuje formularz.
2. Przechowuj wprowadzone usługi w polach prywatnych.
3. Użyj usług w programach obsługi zdarzeń lub innych metodach.

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

Dodawanie konfiguracji

CreateApplicationBuilder automatycznie się ładuje z appsettings.json katalogu wyjściowego. Aby dodać plik konfiguracji:

1. appsettings.json Utwórz plik w katalogu głównym projektu przy użyciu wartości konfiguracji:

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

2. Ustaw CopyToOutputDirectory na PreserveNewest w pliku projektu, aby appsettings.json był kopiowany do katalogu wyjściowego.

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

Treści powiązane

• Iniekcja zależności w .NET
• Gospodarz ogólny .NET
• Rejestrowanie na platformie .NET
• Konfiguracja na platformie .NET