Creare integrazioni del cliente .NET.NET Aspire personalizzate

Questo articolo è una continuazione dell'articolo Creare integrazioni di hosting .NET.NET Aspire personalizzate. Illustra la creazione di un'integrazione client .NET.NET Aspire che usa MailKit per inviare messaggi di posta elettronica. Questa integrazione viene quindi aggiunta all'app Newsletter creata in precedenza. Nell'esempio precedente è stata omessa la creazione di un'integrazione client e si basava invece sul .NETSmtpClientesistente. È consigliabile usare SmtpClient di MailKit al posto di .NETSmtpClient ufficiale per l'invio di messaggi di posta elettronica, perché è più moderno e supporta più funzionalità/protocolli. Per ulteriori informazioni, vedere .NET SmtpClient: Osservazioni.

Prerequisiti

Se stai seguendo questa procedura, dovresti avere un'app Newsletter dai passaggi nell'articolo Creare integrazione hosting personalizzata .NET.NET Aspire.

Consiglio

Questo articolo è ispirato alle integrazioni di .NET.NET Aspire esistenti e in base alle indicazioni ufficiali del team. Ci sono luoghi in cui le indicazioni indicate variano ed è importante comprendere il ragionamento alla base delle differenze. Per altre informazioni, vedere .NET.NET Aspire requisiti di integrazione.

Creare una libreria per l'integrazione

Le integrazioni .NET.NET Aspire vengono recapitate come pacchetti NuGet, ma in questo esempio pubblicare un pacchetto NuGet non è previsto in questo articolo. Creare invece un progetto di libreria di classi contenente l'integrazione e farvi riferimento come progetto. I pacchetti di integrazione .NETe.NET Aspire sono progettati per incapsulare una libreria client, come MailKit, e fornire telemetria pronta per la produzione, controlli di integrità, configurabilità e verificabilità. Iniziamo creando un nuovo progetto di libreria di classi.

1. Creare un nuovo progetto di libreria di classi denominato MailKit.Client nella stessa directory del MailDevResource.sln dell'articolo precedente.

   dotnet new classlib -o MailKit.Client
   

2. Aggiungere il progetto alla soluzione.

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

Il passaggio successivo consiste nell'aggiungere tutti i pacchetti NuGet su cui si basa l'integrazione. Invece di aggiungere ogni pacchetto uno alla volta dalla CLI .NET, è probabilmente più facile copiare e incollare il seguente codice XML nel file MailKit.Client.csproj.

<ItemGroup>
  <PackageReference Include="MailKit" Version="4.10.0" />
  <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.2" />
  <PackageReference Include="Microsoft.Extensions.Resilience" Version="9.2.0" />
  <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.2" />
  <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="9.0.2" />
  <PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.11.2" />
</ItemGroup>

Definire le impostazioni di integrazione

Ogni volta che si crea un'integrazione .NET.NET Aspire, è consigliabile comprendere la libreria client a cui si sta eseguendo il mapping. Con MailKit è necessario comprendere le impostazioni di configurazione necessarie per connettersi a un server SMTP (Simple Mail Transfer Protocol). È tuttavia importante comprendere anche se la libreria include il supporto per le verifiche dello stato di salute , il tracciamento e le metriche . MailKit supporta il tracciamento e le metriche , attraverso la sua classe Telemetry.SmtpClient. Quando si aggiungono controlli di integrità , è consigliabile utilizzare controlli di integrità già stabiliti o esistenti, se possibile. In caso contrario, potresti considerare di implementare la tua soluzione nell'integrazione. Aggiungere il codice seguente al progetto MailKit.Client in un file denominato MailKitClientSettings.cs:

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

Il codice precedente definisce la classe MailKitClientSettings con:

• Endpoint proprietà che rappresenta la stringa di connessione al server SMTP.
• DisableHealthChecks proprietà che determina se le verifiche di salute sono abilitate.
• DisableTracing proprietà che determina se il tracciamento è abilitato.
• DisableMetrics proprietà che determina se le metriche sono abilitate.

Analizzare la logica della stringa di connessione

La classe settings contiene anche un metodo ParseConnectionString che analizza la stringa di connessione in un Urivalido. È previsto che la configurazione venga fornita nel formato seguente:

• ConnectionStrings:<connectionName>: stringa di connessione al server SMTP.
• MailKit:Client:ConnectionString: stringa di connessione al server SMTP.

Se nessuno di questi valori viene specificato, viene generata un'eccezione.

Esporre le funzionalità del client

L'obiettivo delle integrazioni di .NET.NET Aspire è esporre la libreria client sottostante ai consumatori attraverso l'inserimento delle dipendenze. Con MailKit e per questo esempio, la classe SmtpClient è ciò che si vuole esporre. Non stai avvolgendo alcuna funzionalità, ma stai mappando le impostazioni di configurazione a una classe SmtpClient. È comune esporre sia le registrazioni standard che quelle con chiave di servizio per le integrazioni. Le registrazioni standard vengono usate quando è presente una sola istanza di un servizio e le registrazioni di servizi con chiave vengono usate quando sono presenti più istanze di un servizio. In alcuni casi, per ottenere più registrazioni dello stesso tipo si usa un modello factory. Aggiungere il codice seguente al progetto di MailKit.Client in un file denominato MailKitClientFactory.cs:

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();
    }
}

La classe MailKitClientFactory è una factory che crea un'istanza di ISmtpClient in base alle impostazioni di configurazione. È responsabile della restituzione di un'implementazione ISmtpClient con una connessione attiva a un server SMTP configurato. Successivamente, è necessario esporre la funzionalità per i consumatori affinché possano registrare questa factory con il contenitore di iniezione delle dipendenze. Aggiungere il codice seguente al progetto MailKit.Client in un file denominato MailKitExtensions.cs:

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));
        }
    }
}

Il codice precedente aggiunge due metodi di estensione sul tipo IHostApplicationBuilder, uno per la registrazione standard di MailKit e un altro per la registrazione con chiave di MailKit.

Consiglio

I metodi di estensione per le integrazioni di .NET.NET Aspire devono estendere il tipo di IHostApplicationBuilder e seguire la convenzione di denominazione Add<MeaningfulName> in cui il <MeaningfulName> è il tipo o la funzionalità che si sta aggiungendo. Per questo articolo viene usato il metodo di estensione AddMailKitClient per aggiungere il client MailKit. Probabilmente è più in linea con le indicazioni ufficiali per usare AddMailKitSmtpClient invece di AddMailKitClient, poiché questo registra solo il SmtpClient e non l'intera libreria MailKit.

Entrambe le estensioni si basano infine sul metodo AddMailKitClient privato per registrare il MailKitClientFactory con il contenitore di inserimento delle dipendenze come servizio con ambito . Il motivo della registrazione del MailKitClientFactory come servizio con ambito è dovuto al fatto che le operazioni di connessione sono considerate costose e devono essere riutilizzate nello stesso ambito, se possibile. In altre parole, per una singola richiesta, deve essere usata la stessa istanza di ISmtpClient. La fabbrica mantiene l'istanza del SmtpClient che crea e lo elimina.

Legame di configurazione

Una delle prime operazioni eseguite dall'implementazione privata dei metodi di AddMailKitClient consiste nell'associare le impostazioni di configurazione alla classe MailKitClientSettings. Viene istanziata la classe delle impostazioni e successivamente viene chiamata Bind con la sezione specifica della configurazione. Il delegato facoltativo configureSettings viene quindi richiamato con le impostazioni correnti. In questo modo l'utente può configurare ulteriormente le impostazioni, assicurandosi che le impostazioni del codice manuali vengano rispettate rispetto alle impostazioni di configurazione. Successivamente, a seconda di se il valore serviceKey è stato specificato, il MailKitClientFactory deve essere registrato nel contenitore per l'iniezione delle dipendenze come servizio standard o come servizio con chiave.

Importante

È intenzionale il fatto che l'overload implementationFactory venga chiamato durante la registrazione dei servizi. Il metodo CreateMailKitClientFactory solleva un'eccezione quando la configurazione non è valida. In questo modo si garantisce che la creazione del MailKitClientFactory venga posticipata fino a quando è necessaria e impedisce all'app di produrre errori prima che il log sia disponibile.

La registrazione dei controlli sanitari e della telemetria sono descritti in modo più dettagliato nelle sezioni seguenti.

Aggiungere verifiche di integrità

Verifiche dello stato di salute per monitorare lo stato di un'integrazione. Con MailKit è possibile verificare se la connessione al server SMTP è integra. Aggiungere il codice seguente al progetto di MailKit.Client in un file denominato MailKitHealthCheck.cs:

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);
        }
    }
}

Implementazione precedente della verifica dello stato di salute

• Implementa l'interfaccia IHealthCheck.
• Accetta il MailKitClientFactory come parametro del costruttore primario.
• Soddisfa il metodo CheckHealthAsync in base a:
  • Tentare di ottenere un'istanza di ISmtpClient dal factory. In caso di esito positivo, restituisce HealthCheckResult.Healthy.
  • Se viene generata un'eccezione, restituisce HealthCheckResult.Unhealthy.

Come condiviso in precedenza nella registrazione del MailKitClientFactory, il MailKitHealthCheck viene registrato in modo condizionale con il IHeathChecksBuilder:

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

Il consumatore può scegliere di omettere i controlli di salute impostando la proprietà DisableHealthChecks su true nella configurazione. Un modello comune per le integrazioni consiste nell'avere funzionalità opzionali e .NET.NET Aspire incoraggiano fortemente questi tipi di configurazioni. Per altre informazioni sui controlli di integrità e su un esempio funzionante che include un'interfaccia utente, vedere .NET AspireASP.NET Core esempio di HealthChecksUI.

Collegare la telemetria

Come procedura consigliata, la libreria client MailKit espone i dati di telemetria. .NET .NET Aspire può sfruttare questi dati di telemetria e visualizzarla nel dashboard .NET.NET Aspire. A seconda che il tracciamento e le metriche siano abilitati o meno, la telemetria viene configurata come mostrato nel frammento di codice seguente.

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));
}

Aggiornare il servizio Newsletter

Dopo aver creato la libreria di integrazione, è ora possibile aggiornare il servizio Newsletter per usare il client MailKit. Il primo passaggio consiste nell'aggiungere un riferimento al progetto MailKit.Client. Aggiungere il riferimento al progetto MailKit.Client.csproj al progetto MailDevResource.NewsletterService:

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

Aggiungere quindi un riferimento al progetto ServiceDefaults:

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

Il passaggio finale consiste nel sostituire il file di Program.cs esistente nel progetto MailDevResource.NewsletterService con il codice C# seguente:

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();

Le modifiche più importanti nel codice precedente sono:

• Istruzioni using aggiornate che includono i namespace MailKit.Client, MailKit.Net.Smtp, e MimeKit.
• La sostituzione della registrazione per il codice ufficiale .NETSmtpClient con la chiamata al metodo di estensione AddMailKitClient.
• La sostituzione delle chiamate post di mappatura di /subscribe e /unsubscribe con l'iniezione di MailKitClientFactory e l'uso dell'istanza di ISmtpClient per inviare l'email.

Esegui l'esempio

Dopo aver creato l'integrazione del client MailKit e aggiornato il servizio Newsletter per usarlo, è possibile eseguire l'esempio. Nell'IDE selezionare F5 oppure eseguire dotnet run dalla cartella radice della soluzione per avviare l'applicazione—dovresti vedere il dashboard .NET.NET Aspire:

Quando l'applicazione è in esecuzione, passare all'interfaccia utente di Swagger in https://localhost:7251/swagger e testare gli endpoint /subscribe e /unsubscribe. Selezionare la freccia verso il basso per espandere l'endpoint.

Selezionare quindi il pulsante Try it out. Immettere un indirizzo di posta elettronica e quindi selezionare il pulsante Execute.

Ripetere questa operazione più volte per aggiungere più indirizzi di posta elettronica. Verrà visualizzato il messaggio di posta elettronica inviato alla posta in arrivo MailDev:

Arrestare l'applicazione selezionando CTRL+C nella finestra del terminale in cui è in esecuzione l'applicazione oppure selezionando il pulsante arresta nell'IDE.

Visualizzare i dati di telemetria di MailKit

La libreria client MailKit espone i dati di telemetria che possono essere visualizzati nel dashboard .NET.NET Aspire. Per visualizzare i dati di telemetria, accedere al dashboard .NET.NET Aspire in https://localhost:7251. Selezionare la risorsa newsletter per visualizzare i dati di telemetria nella pagina Metriche.

Aprire di nuovo l'interfaccia utente di Swagger e inviare alcune richieste agli endpoint /subscribe e /unsubscribe. Tornare quindi al dashboard .NET.NET Aspire e selezionare la risorsa newsletter. Selezionare una metrica nel nodo mailkit.net.smtp, ad esempio mailkit.net.smtp.client.operation.count. Verranno visualizzati i dati di telemetria per il client MailKit:

Sommario

In questo articolo si è appreso come creare un'integrazione .NET.NET Aspire che usa MailKit per inviare messaggi di posta elettronica. Si è anche appreso come integrare questa integrazione nell'app Newsletter creata in precedenza. Hai imparato i principi di base delle integrazioni di .NET.NET Aspire, come rendere accessibile la libreria client di base ai consumatori tramite l'iniezione di dipendenze, e come aggiungere verifiche dello stato di salute e telemetria all'integrazione. Si è anche appreso come aggiornare il servizio Newsletter per usare il client MailKit.

Vai avanti e crea le tue integrazioni .NET.NET Aspire. Se ritieni che l'integrazione che stai creando abbia un valore sufficiente per la comunità, considera la possibilità di pubblicarla come pacchetto NuGet affinché altri possano usarla. Inoltre, prendi in considerazione l'invio di una richiesta pull al repository .NET AspireGitHub per la possibile inclusione nelle integrazioni ufficiali .NET.NET Aspire.

Passaggi successivi

Comunicazione Sicura tra l'Hosting e le Integrazioni Client