Erstellen Sie benutzerdefinierte .NET Aspireclient-Integrationen

Dieser Artikel ist eine Fortsetzung des Artikels Erstellen von benutzerdefinierten .NET.NET Aspire Hostingintegrationen. Es leitet Sie durch die Erstellung einer .NET Aspireclient-Integration, die MailKit zum Versenden von E-Mails verwendet. Diese Integration wird dann der Newsletter-App hinzugefügt, die Sie zuvor erstellt haben. Im vorherigen Beispiel wurde die Erstellung einer client-Integration ausgelassen, und es wurde stattdessen auf die vorhandene .NETSmtpClientzurückgegriffen. Es ist am besten, MailKits SmtpClient anstelle der offiziellen .NETSmtpClient für den Versand von E-Mails zu nutzen, da es moderner ist und mehr Funktionen/Protokolle unterstützt. Weitere Informationen finden Sie unter .NET SmtpClient: Hinweise.

Voraussetzungen

Wenn Sie die bisherigen Schritte befolgt haben, sollten Sie über eine Newsletter-App aus dem Artikel Erstellen von benutzerdefinierten .NET.NET Aspire Hostingintegration verfügen.

Trinkgeld

Dieser Artikel ist inspiriert von bestehenden .NET.NET Aspire Integrationen und basiert auf den offiziellen Leitlinien des Teams. Es gibt Orte, an denen diese Anleitungen variieren, und es ist wichtig, die Gründe für die Unterschiede zu verstehen. Weitere Informationen finden Sie unter .NET.NET Aspire Integrationsanforderungen.

Erstellen einer Bibliothek für die Integration

.NET .NET Aspire Integrationen werden als NuGet-Pakete bereitgestellt. In diesem Beispiel liegt es jedoch außerhalb des Umfangs dieses Artikels, ein NuGet-Paket zu veröffentlichen. Stattdessen erstellen Sie ein Klassenbibliotheksprojekt, das die Integration enthält, und verweisen als Projekt darauf. Die .NET Aspire-Integrationspakete sind dazu gedacht, eine client-Bibliothek wie MailKit zu umfassen und produktionsreife Telemetrie, Funktionsprüfungen, Konfigurierbarkeit und Testbarkeit bereitzustellen. Beginnen wir mit dem Erstellen eines neuen Klassenbibliotheksprojekts.

1. Erstellen Sie ein neues Klassenbibliotheksprojekt mit dem Namen MailKit.Client im selben Verzeichnis wie die MailDevResource.sln aus dem vorherigen Artikel.

   dotnet new classlib -o MailKit.Client
   

2. Fügen Sie das Projekt der Projektmappe hinzu.

   dotnet sln ./MailDevResource.sln add MailKit.Client/MailKit.Client.csproj
   

Der nächste Schritt besteht darin, alle NuGet-Pakete hinzuzufügen, auf denen die Integration basiert. Anstatt jedes Paket einzeln aus der .NET CLI hinzuzufügen, ist es wahrscheinlich einfacher, die folgende XML-Datei in das MailKit zu kopieren und einzufügen.ClientCSPROJ-datei.

<ItemGroup>
  <PackageReference Include="MailKit" Version="4.9.0" />
  <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.0" />
  <PackageReference Include="Microsoft.Extensions.Resilience" Version="9.0.0" />
  <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.0" />
  <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="9.0.0" />
  <PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.10.0" />
</ItemGroup>

Integrationseinstellungen definieren

Immer wenn Sie eine .NET Aspire Integration erstellen, sollten Sie die client Bibliothek verstehen, der Sie zuordnen. Mit MailKit müssen Sie die Konfigurationseinstellungen verstehen, die zum Herstellen einer Verbindung mit einem Simple Mail Transfer Protocol (SMTP) servererforderlich sind. Aber es ist auch wichtig zu verstehen, ob die Bibliothek Unterstützung für Gesundheitsprüfungen, Ablaufverfolgung und Metrikenbietet. MailKit unterstützt Tracing- und Metrikenüber seine Telemetry.SmtpClient-Klasse. Wenn Sie Integritätsprüfungenhinzufügen, sollten Sie nach Möglichkeit etablierte oder vorhandene Integritätsprüfungen verwenden. Andernfalls können Sie in Erwägung ziehen, Ihre eigene Lösung in die Integration zu implementieren. Fügen Sie dem MailKit.Client Projekt in einer Datei mit dem Namen MailKitClientSettings.csden folgenden Code hinzu:

using System.Data.Common;

namespace MailKit.Client;

/// <summary>
/// Provides the client configuration settings for connecting MailKit to an SMTP server.
/// </summary>
public sealed class MailKitClientSettings
{
    internal const string DefaultConfigSectionName = "MailKit:Client";

    /// <summary>
    /// Gets or sets the SMTP server <see cref="Uri"/>.
    /// </summary>
    /// <value>
    /// The default value is <see langword="null"/>.
    /// </value>
    public Uri? Endpoint { get; set; }

    /// <summary>
    /// Gets or sets a boolean value that indicates whether the database health check is disabled or not.
    /// </summary>
    /// <value>
    /// The default value is <see langword="false"/>.
    /// </value>
    public bool DisableHealthChecks { get; set; }

    /// <summary>
    /// Gets or sets a boolean value that indicates whether the OpenTelemetry tracing is disabled or not.
    /// </summary>
    /// <value>
    /// The default value is <see langword="false"/>.
    /// </value>
    public bool DisableTracing { get; set; }

    /// <summary>
    /// Gets or sets a boolean value that indicates whether the OpenTelemetry metrics are disabled or not.
    /// </summary>
    /// <value>
    /// The default value is <see langword="false"/>.
    /// </value>
    public bool DisableMetrics { get; set; }

    internal void ParseConnectionString(string? connectionString)
    {
        if (string.IsNullOrWhiteSpace(connectionString))
        {
            throw new InvalidOperationException($"""
                    ConnectionString is missing.
                    It should be provided in 'ConnectionStrings:<connectionName>'
                    or '{DefaultConfigSectionName}:Endpoint' key.'
                    configuration section.
                    """);
        }

        if (Uri.TryCreate(connectionString, UriKind.Absolute, out var uri))
        {
            Endpoint = uri;
        }
        else
        {
            var builder = new DbConnectionStringBuilder
            {
                ConnectionString = connectionString
            };
            
            if (builder.TryGetValue("Endpoint", out var endpoint) is false)
            {
                throw new InvalidOperationException($"""
                        The 'ConnectionStrings:<connectionName>' (or 'Endpoint' key in
                        '{DefaultConfigSectionName}') is missing.
                        """);
            }

            if (Uri.TryCreate(endpoint.ToString(), UriKind.Absolute, out uri) is false)
            {
                throw new InvalidOperationException($"""
                        The 'ConnectionStrings:<connectionName>' (or 'Endpoint' key in
                        '{DefaultConfigSectionName}') isn't a valid URI.
                        """);
            }

            Endpoint = uri;
        }
    }
}

Der vorangehende Code definiert die MailKitClientSettings Klasse mit:

• Endpoint Eigenschaft, die die Verbindungszeichenfolge zum SMTP-serverdarstellt.
• DisableHealthChecks Eigenschaft, die bestimmt, ob Integritätsprüfungen aktiviert sind.
• DisableTracing Eigenschaft, die bestimmt, ob die Ablaufverfolgung aktiviert ist.
• DisableMetrics Eigenschaft, die bestimmt, ob Metriken aktiviert sind.

Analysieren der Logik von Verbindungszeichenfolgen

Die Einstellungsklasse enthält auch eine ParseConnectionString Methode, die die Verbindungszeichenfolge in eine gültige Urianalysiert. Es wird erwartet, dass die Konfiguration im folgenden Format bereitgestellt wird:

• ConnectionStrings:<connectionName>: Die Verbindungszeichenfolge für den SMTP-server.
• MailKit:Client:ConnectionString: Die Verbindungszeichenfolge für SMTP-server.

Wenn keiner dieser Werte angegeben wird, wird eine Ausnahme ausgelöst.

Verfügbarmachen client Funktionalität

Ziel von .NET Aspire-Integrationen ist es, die zugrunde liegende client-Bibliothek durch Abhängigkeitsinjektion den Nutzern zur Verfügung zu stellen. Bei MailKit und in diesem Beispiel ist die SmtpClient Klasse das, was Sie freigeben möchten. Sie umschließen keine Funktionen, sondern zuordnen Konfigurationseinstellungen zu einer SmtpClient Klasse. Es ist üblich, sowohl Standard- als auch schlüsselbasierte Dienstregistrierungen bei Integrationen verfügbar zu machen. Standardregistrierungen werden verwendet, wenn nur eine Instanz eines Diensts vorhanden ist, und Schlüsseldienstregistrierungen werden verwendet, wenn mehrere Instanzen eines Diensts vorhanden sind. Manchmal verwenden Sie ein Factory-Pattern, um mehrere Registrierungen desselben Typs zu erreichen. Fügen Sie dem MailKit.Client Projekt den folgenden Code in einer Datei mit dem Namen MailKitClientFactory.cshinzu:

using MailKit.Net.Smtp;

namespace MailKit.Client;

/// <summary>
/// A factory for creating <see cref="ISmtpClient"/> instances
/// given a <paramref name="smtpUri"/> (and optional <paramref name="credentials"/>).
/// </summary>
/// <param name="settings">
/// The <see cref="MailKitClientSettings"/> settings for the SMTP server
/// </param>
public sealed class MailKitClientFactory(MailKitClientSettings settings) : IDisposable
{
    private readonly SemaphoreSlim _semaphore = new(1, 1);

    private SmtpClient? _client;

    /// <summary>
    /// Gets an <see cref="ISmtpClient"/> instance in the connected state
    /// (and that's been authenticated if configured).
    /// </summary>
    /// <param name="cancellationToken">Used to abort client creation and connection.</param>
    /// <returns>A connected (and authenticated) <see cref="ISmtpClient"/> instance.</returns>
    /// <remarks>
    /// Since both the connection and authentication are considered expensive operations,
    /// the <see cref="ISmtpClient"/> returned is intended to be used for the duration of a request
    /// (registered as 'Scoped') and is automatically disposed of.
    /// </remarks>
    public async Task<ISmtpClient> GetSmtpClientAsync(
        CancellationToken cancellationToken = default)
    {
        await _semaphore.WaitAsync(cancellationToken);

        try
        {
            if (_client is null)
            {
                _client = new SmtpClient();

                await _client.ConnectAsync(settings.Endpoint, cancellationToken)
                             .ConfigureAwait(false);
            }
        }
        finally
        {
            _semaphore.Release();
        }       

        return _client;
    }

    public void Dispose()
    {
        _client?.Dispose();
        _semaphore.Dispose();
    }
}

Die MailKitClientFactory Klasse ist eine Factory, die basierend auf den Konfigurationseinstellungen eine ISmtpClient Instanz erstellt. Es ist verantwortlich für das Zurückgeben einer ISmtpClient-Implementierung, die eine aktive Verbindung zu einem konfigurierten SMTP-serverhat. Als Nächstes müssen Sie die Funktionalität für die Konsumenten verfügbar machen, um diese Factory mit dem Dependency Injection Container zu registrieren. Fügen Sie dem MailKit.Client Projekt den folgenden Code in einer Datei mit dem Namen MailKitExtensions.cshinzu:

using MailKit;
using MailKit.Client;
using MailKit.Net.Smtp;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace Microsoft.Extensions.Hosting;

/// <summary>
/// Provides extension methods for registering a <see cref="SmtpClient"/> as a
/// scoped-lifetime service in the services provided by the <see cref="IHostApplicationBuilder"/>.
/// </summary>
public static class MailKitExtensions
{
    /// <summary>
    /// Registers 'Scoped' <see cref="MailKitClientFactory" /> for creating
    /// connected <see cref="SmtpClient"/> instance for sending emails.
    /// </summary>
    /// <param name="builder">
    /// The <see cref="IHostApplicationBuilder" /> to read config from and add services to.
    /// </param>
    /// <param name="connectionName">
    /// A name used to retrieve the connection string from the ConnectionStrings configuration section.
    /// </param>
    /// <param name="configureSettings">
    /// An optional delegate that can be used for customizing options.
    /// It's invoked after the settings are read from the configuration.
    /// </param>
    public static void AddMailKitClient(
        this IHostApplicationBuilder builder,
        string connectionName,
        Action<MailKitClientSettings>? configureSettings = null) =>
        AddMailKitClient(
            builder,
            MailKitClientSettings.DefaultConfigSectionName,
            configureSettings,
            connectionName,
            serviceKey: null);

    /// <summary>
    /// Registers 'Scoped' <see cref="MailKitClientFactory" /> for creating
    /// connected <see cref="SmtpClient"/> instance for sending emails.
    /// </summary>
    /// <param name="builder">
    /// The <see cref="IHostApplicationBuilder" /> to read config from and add services to.
    /// </param>
    /// <param name="name">
    /// The name of the component, which is used as the <see cref="ServiceDescriptor.ServiceKey"/> of the
    /// service and also to retrieve the connection string from the ConnectionStrings configuration section.
    /// </param>
    /// <param name="configureSettings">
    /// An optional method that can be used for customizing options. It's invoked after the settings are
    /// read from the configuration.
    /// </param>
    public static void AddKeyedMailKitClient(
        this IHostApplicationBuilder builder,
        string name,
        Action<MailKitClientSettings>? configureSettings = null)
    {
        ArgumentNullException.ThrowIfNull(name);

        AddMailKitClient(
            builder,
            $"{MailKitClientSettings.DefaultConfigSectionName}:{name}",
            configureSettings,
            connectionName: name,
            serviceKey: name);
    }

    private static void AddMailKitClient(
        this IHostApplicationBuilder builder,
        string configurationSectionName,
        Action<MailKitClientSettings>? configureSettings,
        string connectionName,
        object? serviceKey)
    {
        ArgumentNullException.ThrowIfNull(builder);

        var settings = new MailKitClientSettings();

        builder.Configuration
               .GetSection(configurationSectionName)
               .Bind(settings);

        if (builder.Configuration.GetConnectionString(connectionName) is string connectionString)
        {
            settings.ParseConnectionString(connectionString);
        }

        configureSettings?.Invoke(settings);

        if (serviceKey is null)
        {
            builder.Services.AddScoped(CreateMailKitClientFactory);
        }
        else
        {
            builder.Services.AddKeyedScoped(serviceKey, (sp, key) => CreateMailKitClientFactory(sp));
        }

        MailKitClientFactory CreateMailKitClientFactory(IServiceProvider _)
        {
            return new MailKitClientFactory(settings);
        }

        if (settings.DisableHealthChecks is false)
        {
            builder.Services.AddHealthChecks()
                .AddCheck<MailKitHealthCheck>(
                    name: serviceKey is null ? "MailKit" : $"MailKit_{connectionName}",
                    failureStatus: default,
                    tags: []);
        }

        if (settings.DisableTracing is false)
        {
            builder.Services.AddOpenTelemetry()
                .WithTracing(
                    traceBuilder => traceBuilder.AddSource(
                        Telemetry.SmtpClient.ActivitySourceName));
        }

        if (settings.DisableMetrics is false)
        {
            // Required by MailKit to enable metrics
            Telemetry.SmtpClient.Configure();

            builder.Services.AddOpenTelemetry()
                .WithMetrics(
                    metricsBuilder => metricsBuilder.AddMeter(
                        Telemetry.SmtpClient.MeterName));
        }
    }
}

Der vorangehende Code fügt zwei Erweiterungsmethoden für den IHostApplicationBuilder Typ hinzu, eine für die Standardregistrierung von MailKit und eine weitere für die Schlüsselregistrierung von MailKit.

Trinkgeld

Erweiterungsmethoden für .NET.NET Aspire Integrationen sollten den IHostApplicationBuilder Typ erweitern und der Add<MeaningfulName> Benennungskonvention folgen, wobei die <MeaningfulName> der Typ oder die Funktionalität ist, die Sie hinzufügen. In diesem Artikel wird die AddMailKitClient-Erweiterungsmethode verwendet, um das MailKit clienthinzuzufügen. Es ist wahrscheinlich mehr in Einklang mit den offiziellen Anleitungen, AddMailKitSmtpClient anstelle von AddMailKitClientzu verwenden, da dies nur die SmtpClient und nicht die gesamte MailKit-Bibliothek registriert.

Beide Erweiterungen basieren letztendlich auf der privaten AddMailKitClient-Methode, um die MailKitClientFactory beim Abhängigkeitseinfügungscontainer als bereichsbezogenen Dienstzu registrieren. Der Grund für die Registrierung der MailKitClientFactory als bereichsbezogenen Dienst ist, dass die Verbindungsvorgänge als teuer betrachtet werden und nach Möglichkeit innerhalb desselben Bereichs wiederverwendet werden sollten. Anders ausgedrückt: Für eine einzelne Anforderung sollte dieselbe ISmtpClient Instanz verwendet werden. Die Fabrik behält die Instanz der SmtpClient, die sie erstellt, bei sich und entsorgt sie.

Konfigurationsbindung

Eine der ersten Aktionen, die die private Implementierung der AddMailKitClient-Methoden ausführt, besteht darin, die Konfigurationseinstellungen an die MailKitClientSettings Klasse zu binden. Die Einstellungsklasse wird instanziiert und dann Bind mit dem spezifischen Konfigurationsabschnitt aufgerufen. Anschließend wird der optionale configureSettings Delegat mit den aktuellen Einstellungen aufgerufen. Auf diese Weise kann der Benutzer die Einstellungen weiter konfigurieren und sicherstellen, dass manuelle Codeeinstellungen Vorrang vor Konfigurationseinstellungen haben. Je nachdem, ob der serviceKey Wert bereitgestellt wurde, sollte die MailKitClientFactory als Dienst mit Standardschlüssel oder spezifisch gekennzeichneter Dienst im Abhängigkeitsinjektions-Container registriert werden.

Wichtig

Es ist beabsichtigt, dass die überladene implementationFactory beim Registrieren von Diensten aufgerufen wird. Die CreateMailKitClientFactory Methode wird ausgelöst, wenn die Konfiguration ungültig ist. Dadurch wird sichergestellt, dass die Erstellung der MailKitClientFactory zurückgestellt wird, bis sie benötigt wird, und es wird verhindert, dass die App einen Fehler verursacht, bevor die Protokollierung verfügbar ist.

Die Registrierung von Gesundheitsüberprüfungen und Telemetrie wird in den folgenden Abschnitten etwas ausführlicher beschrieben.

Hinzufügen von Gesundheitsprüfungen

Gesundheitschecks sind eine Möglichkeit, die Gesundheit einer Integration zu überwachen. Mit MailKit können Sie überprüfen, ob die Verbindung mit dem SMTP-server fehlerfrei ist. Fügen Sie dem MailKit.Client Projekt in einer Datei mit dem Namen MailKitHealthCheck.csden folgenden Code hinzu:

using Microsoft.Extensions.Diagnostics.HealthChecks;

namespace MailKit.Client;

internal sealed class MailKitHealthCheck(MailKitClientFactory factory) : IHealthCheck
{
    public async Task<HealthCheckResult> CheckHealthAsync(
        HealthCheckContext context,
        CancellationToken cancellationToken = default)
    {
        try
        {
            // The factory connects (and authenticates).
            _ = await factory.GetSmtpClientAsync(cancellationToken);

            return HealthCheckResult.Healthy();
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy(exception: ex);
        }
    }
}

Die vorherige Implementierung des Gesundheitschecks:

• Implementiert die IHealthCheck-Schnittstelle.
• Akzeptiert die MailKitClientFactory als primären Konstruktorparameter.
• Erfüllt die Methode CheckHealthAsync durch:
  • Es wird versucht, eine ISmtpClient Instanz aus dem factoryabzurufen. Wenn dies erfolgreich ist, wird HealthCheckResult.Healthyzurückgegeben.
  • Wenn eine Ausnahme ausgelöst wird, wird HealthCheckResult.Unhealthyzurückgegeben.

Wie zuvor bei der Registrierung von MailKitClientFactorygeteilt, wird MailKitHealthCheck bedingt bei IHeathChecksBuilderregistriert.

if (settings.DisableHealthChecks is false)
{
    builder.Services.AddHealthChecks()
        .AddCheck<MailKitHealthCheck>(
            name: serviceKey is null ? "MailKit" : $"MailKit_{connectionName}",
            failureStatus: default,
            tags: []);
}

Der Benutzer kann die Gesundheitsprüfungen weglassen, indem er die Eigenschaft DisableHealthChecks in der Konfiguration auf true festlegt. Ein gängiges Muster für Integrationen besteht darin, optionale Features zu haben, und .NET.NET Aspire Integrationen fördern diese Arten von Konfigurationen stark. Weitere Informationen zu Gesundheitsprüfungen und einem funktionierenden Beispiel, das eine Benutzeroberfläche enthält, finden Sie unter .NET AspireASP.NET Core HealthChecksUI sample.

Telemetrie einrichten

Als bewährte Methode macht die MailKit-client-Bibliothek Telemetrie-verfügbar. .NET .NET Aspire können diese Telemetrie nutzen und sie im .NET.NET Aspire Dashboardanzeigen. Je nachdem, ob Ablaufverfolgung und Metriken aktiviert sind, wird Telemetrie wie im folgenden Codeausschnitt dargestellt verkabelt:

if (settings.DisableTracing is false)
{
    builder.Services.AddOpenTelemetry()
        .WithTracing(
            traceBuilder => traceBuilder.AddSource(
                Telemetry.SmtpClient.ActivitySourceName));
}

if (settings.DisableMetrics is false)
{
    // Required by MailKit to enable metrics
    Telemetry.SmtpClient.Configure();

    builder.Services.AddOpenTelemetry()
        .WithMetrics(
            metricsBuilder => metricsBuilder.AddMeter(
                Telemetry.SmtpClient.MeterName));
}

Aktualisieren des Newsletterdiensts

Mit der erstellten Integrationsbibliothek können Sie jetzt den Newsletter-Dienst aktualisieren, um das MailKit-clientzu verwenden. Der erste Schritt besteht darin, einen Verweis auf das MailKit.Client Projekt hinzuzufügen. Fügen Sie den MailKitClient.csproj Projektverweis zum MailDevResource.NewsletterService Projekt hinzu.

dotnet add ./MailDevResource.NewsletterService/MailDevResource.NewsletterService.csproj reference MailKit.Client/MailKit.Client.csproj

Fügen Sie als Nächstes einen Verweis auf das ServiceDefaults Projekt hinzu:

dotnet add ./MailDevResource.NewsletterService/MailDevResource.NewsletterService.csproj reference MailDevResource.ServiceDefaults/MailDevResource.ServiceDefaults.csproj

Der letzte Schritt besteht darin, die vorhandene Program.cs-Datei im MailDevResource.NewsletterService Projekt durch den folgenden C#-Code zu ersetzen:

using System.Net.Mail;
using MailKit.Client;
using MailKit.Net.Smtp;
using MimeKit;

var builder = WebApplication.CreateBuilder(args);

builder.AddServiceDefaults();

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Add services to the container.
builder.AddMailKitClient("maildev");

var app = builder.Build();

app.MapDefaultEndpoints();

// Configure the HTTP request pipeline.

app.UseSwagger();
app.UseSwaggerUI();
app.UseHttpsRedirection();

app.MapPost("/subscribe",
    async (MailKitClientFactory factory, string email) =>
{
    ISmtpClient client = await factory.GetSmtpClientAsync();

    using var message = new MailMessage("newsletter@yourcompany.com", email)
    {
        Subject = "Welcome to our newsletter!",
        Body = "Thank you for subscribing to our newsletter!"
    };

    await client.SendAsync(MimeMessage.CreateFromMailMessage(message));
});

app.MapPost("/unsubscribe",
    async (MailKitClientFactory factory, string email) =>
{
    ISmtpClient client = await factory.GetSmtpClientAsync();

    using var message = new MailMessage("newsletter@yourcompany.com", email)
    {
        Subject = "You are unsubscribed from our newsletter!",
        Body = "Sorry to see you go. We hope you will come back soon!"
    };

    await client.SendAsync(MimeMessage.CreateFromMailMessage(message));
});

app.Run();

Die wichtigsten Änderungen im vorherigen Code sind:

• Die aktualisierten using-Anweisungen, die die Namespaces MailKit.Client, MailKit.Net.Smtpund MimeKit enthalten.
• Das Ersetzen der Registrierung des offiziellen .NETSmtpClient mittels des Aufrufs der Erweiterungsmethode AddMailKitClient.
• Die Ersetzung der /subscribe- und /unsubscribe-Map-Postanrufe, um stattdessen die MailKitClientFactory zu integrieren und die ISmtpClient-Instanz zu verwenden, um die E-Mail zu senden.

Beispiel ausführen

Nachdem Sie nun die MailKit-client-Integration erstellt und den Newsletterdienst aktualisiert haben, um ihn zu verwenden, können Sie die Beispielanwendung ausführen. Wählen Sie in Ihrer IDE F5- aus, oder führen Sie dotnet run aus dem Stammverzeichnis der Lösung aus, um die Anwendung zu starten. Sie sollten das .NET.NET Aspire Dashboardsehen:

Wenn die Anwendung ausgeführt wird, navigieren Sie zur Swagger-Benutzeroberfläche bei https://localhost:7251/swagger und testen Sie die Endpunkte /subscribe und /unsubscribe. Wählen Sie den Abwärtspfeil aus, um den Endpunkt zu erweitern:

Wählen Sie dann die Schaltfläche Try it out aus. Geben Sie eine E-Mail-Adresse ein, und wählen Sie dann die Schaltfläche Execute aus.

Wiederholen Sie diesen Vorgang mehrmals, um mehrere E-Mail-Adressen hinzuzufügen. Sie sollten die an den MailDev-Posteingang gesendete E-Mail sehen:

Beenden Sie die Anwendung, indem Sie STRG+C- im Terminalfenster auswählen, in dem die Anwendung ausgeführt wird, oder indem Sie die Stoppschaltfläche in Ihrer IDE auswählen.

MailKit-Telemetrie anzeigen

Die MailKit-client-Bibliothek macht Telemetrie verfügbar, die im .NET Aspire-Dashboard angezeigt werden kann. Um die Telemetrie anzuzeigen, navigieren Sie zum .NET.NET Aspire Dashboard auf https://localhost:7251. Wählen Sie die Ressource newsletter aus, um die Telemetrie auf der Metrikenseite anzuzeigen.

Öffnen Sie die Benutzeroberfläche von Swagger erneut, und stellen Sie einige Anforderungen an die endpunkte /subscribe und /unsubscribe. Navigieren Sie dann zurück zum .NET.NET Aspire-Dashboard, und wählen Sie die Ressource newsletter aus. Wählen Sie eine Metrik unter dem mailkit.net.smtp-Knoten aus, z. B. mailkit.net.smtp.client.operation.count. Du solltest die Telemetriedaten für das MailKit clientsehen:

Zusammenfassung

In diesem Artikel haben Sie erfahren, wie Sie eine .NET.NET Aspire Integration erstellen, die MailKit zum Senden von E-Mails verwendet. Außerdem haben Sie erfahren, wie Sie diese Integration in die zuvor von Ihnen erstellten Newsletter-App integrieren. Sie haben die Kernprinzipien von .NET Aspire Integrationen kennengelernt, z. B. das Verfügbarmachen der zugrunde liegenden client Bibliothek für Verbraucher durch Abhängigkeitsinjektion und das Hinzufügen von Integritätsprüfungen und Telemetrie zur Integration. Außerdem haben Sie erfahren, wie Sie den Newsletter-Dienst auf die Verwendung des MailKit-clientaktualisieren.

Fahren Sie fort, und erstellen Sie Ihre eigenen .NET.NET Aspire Integrationen. Wenn Sie der Meinung sind, dass in der Integration, die Sie erstellen, genügend Community-Wert vorhanden ist, sollten Sie es als NuGet-Paket veröffentlichen, für andere zu verwenden. Darüber hinaus erwägen Sie, eine Pull-Anforderung an das .NET AspireGitHub Repository zu übermitteln,, um in die offiziellen .NET.NET Aspire Integrationen einbezogen zu werden.

Nächste Schritte

Sichere Kommunikation zwischen Hosting und client Integrationen