Verwenden des generischen .NET-Hosts in einer Windows Forms-App

Der .NET Generic Host bietet eine standardisierte Möglichkeit zum Konfigurieren und Ausführen von Anwendungen mit integrierter Unterstützung für Abhängigkeitsinjektion (Dependency Injection, DI), Konfiguration und Protokollierung. Windows Forms-Apps enthalten standardmäßig keine generische Hostintegration, aber Sie können sie hinzufügen. In diesem Artikel wird gezeigt, wie Sie den generischen Host in einer Windows Forms-App einrichten, um Dienste in Ihre Formulare einzufügen.

Voraussetzungen

• Das Microsoft.Extensions.Hosting NuGet-Paket.

Einrichten des generischen Hosts

Das Setup unterscheidet sich geringfügig zwischen C# und Visual Basic. Konfigurieren Sie in C# den Host direkt in Program.cs. Verwenden Sie in Visual Basic die Start- und Beenden-Ereignisse des Anwendungs-Frameworks in 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

Registrieren und Nutzen von Diensten

Registrieren Sie beim konfigurierten Host benutzerdefinierte Dienste, und fügen Sie sie in Ihre Formulare ein. So erstellen und registrieren Sie einen Dienst:

1. Definieren einer Dienstschnittstelle:

   public interface IGreetingService
   {
       string GetGreeting();
   }
   

   Public Interface IGreetingService
       Function GetGreeting() As String
   End Interface
   

2. Erstellen Sie eine Klasse, die die Schnittstelle implementiert. Die GreetingService Klasse injiziert IConfiguration, um die Begrüßungsnachricht von appsettings.json zu lesen:

   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. Registrieren Sie die Schnittstelle und Implementierung in der Eigenschaft des Builders Services, wie im Abschnitt Generic Host einrichten gezeigt.

Ausführen eines gehosteten Diensts

Der generische Host kann auch Hintergrunddienste ausführen, die am Anwendungslebenszyklus teilnehmen. Implementieren Sie IHostedService, um Rückrufe zu empfangen, wenn der Host startet und stoppt. So fügen Sie einen gehosteten Dienst hinzu:

1. Erstellen Sie eine Klasse, die das IHostedService implementiert. Die folgende Klasse schreibt in die Debugausgabe, sobald der Host gestartet wird und endet.

   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. Registrieren Sie den Dienst bei AddHostedService in der Eigenschaft Services des Builders, wie im Abschnitt Generic Host einrichten gezeigt.

Der Host ruft StartAsync beim Starten und StopAsync beim Herunterfahren auf, sodass die Debugausgabe im Ausgabefenster in Visual Studio angezeigt wird.

Nutzen von Diensten in einem Formular

Da Form1 aus dem DI-Container aufgelöst wird, funktioniert die Konstruktoreinfügung direkt:

1. Fügen Sie Konstruktorparameter für jeden Dienst hinzu, den das Formular benötigt.
2. Speichern Sie die eingefügten Dienste in privaten Feldern.
3. Verwenden Sie die Dienste in Ereignishandlern oder anderen Methoden.

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

Hinzufügen einer Konfiguration

CreateApplicationBuilder lädt appsettings.json automatisch aus dem Ausgabeverzeichnis. So fügen Sie eine Konfigurationsdatei hinzu:

1. Erstellen Sie eine appsettings.json Datei im Projektstamm mit Ihren Konfigurationswerten:

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

2. Setzen Sie CopyToOutputDirectory auf PreserveNewest in der Projektdatei, damit appsettings.json in das Ausgabeverzeichnis kopiert wird.

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

Verwandte Inhalte

• Abhängigkeitsinjektion in .NET
• Generischer .NET-Host
• Anmelden in .NET
• Konfiguration in .NET