Wie man eine SMS mit .Net 6 Minimal API sendet

Ich schaue mir seit einiger Zeit die Vorabversionen von .Net 6 an, und eine der spannenden Funktionen, über die viele Leute gesprochen haben, sind die Minimal-APIs. Obwohl die Meinungen sehr geteilt zu sein scheinen, halte ich sie für eine willkommene Ergänzung. Sie nehmen ASP.NET MVC einen großen Teil der Last ab und senken die Einstiegshürde mit einem ähnlichen Gefühl wie ExpressJS in NodeJS.

Vor etwas mehr als einem Jahr haben wir einen Blogbeitrag mit dem Titel "Wie man eine SMS mit ASP.NET Core MVC versendet". Mit der Veröffentlichung von .Net 6 dachte ich, es wäre eine gute Idee, sich inspirieren zu lassen und zu sehen, wie es wäre, die neue Minimal-API-Syntax zu verwenden, um dieselbe Funktionalität zu emulieren.

Gib mir einfach den Code

Sie können direkt zum Code auf GitHub.

Voraussetzungen

• .Net 6 RC 2 SDK oder höher

• Visual Studio 2022 Vorschau oder Visual Studio Code

Vonage API-Konto

Um dieses Tutorial durchzuführen, benötigen Sie ein Vonage API-Konto. Wenn Sie noch keines haben, können Sie sich noch heute anmelden und mit einem kostenlosen Guthaben beginnen. Sobald Sie ein Konto haben, finden Sie Ihren API-Schlüssel und Ihr API-Geheimnis oben auf dem Vonage-API-Dashboard.

Sind Sie bereit, mit dem Bau zu beginnen?

Erleben Sie nahtlose Konnektivität, Echtzeit-Messaging und kristallklare Sprach- und Videoanrufe - alles auf Knopfdruck.

Das Projekt erstellen

Der einfachste Weg, ein neues Minimal-API-Projekt zu erstellen, ist die Verwendung des folgenden Befehls

dotnet new web -o SmsDotnetMinimalApi

Microsoft hat auch eine großartiges Lernprogramm zum Erstellen eines neuen Minimal-API-Projekts mit Visual Studio.

Wir sollten nun eine API mit einem "Hello World"-Endpunkt haben. Dazu werden wir zwei NuGet-Pakete hinzufügen, das erste ist Vonage's .Net SDK Version 5.9.2 zum Zeitpunkt des Schreibens. Da es sich um eine API handeln wird, werden wir keine Benutzeroberfläche haben. Das zweite Paket ist Swashbuckle / Swagger, mit dem wir alle von uns erstellten Endpunkte einfach ausprobieren können.

dotnet add package Vonage
dotnet add package Swashbuckle.AspNetCore

Klein ist schön

Zusammen mit dem üblichen appsettings.jsonwird Ihr neu erstelltes Projekt aus einer einzigen Datei bestehen, Program.cs. Dies ist wirklich minimal, zumindest für ein ASP.Net-Projekt.

.Net 6 Project

Öffnen wir Program.csund es sollte wie folgt aussehen.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/", () => "Hello World!");

app.Run();

Dies ist alles, was Sie brauchen, um eine vollwertige .NET-API in einer einzigen Datei zu haben. Dies ist ein viel leichterer Ausgangspunkt für die Entwicklung einer kleinen API oder eines Microservices. Und um ehrlich zu sein, es verblüfft mich immer noch, wenn ich daran denke, wie viel Code WebAPI benötigen würde, um das gleiche Ergebnis zu erzielen.

Konfiguration

Fangen wir an, indem wir einige Einstellungen hinzufügen. Innerhalb von appsettings.json müssen wir unseren Vonage-Schlüssel und -Geheimnis hinzufügen. Diese werden verwendet, um Ihre Anwendung bei den Diensten von Vonage zu authentifizieren, und befinden sich oben im Dashboard.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "Vonage_key": "ab12c3de",
  "Vonage_secret": "ZKSQ1vlzNvyZnQCI"
}

Derzeit haben wir keine Dependency Injection konfiguriert, also fügen wir die Klasse VonageClient zur Services-Sammlung hinzu. Dadurch kann sie in jede Klasse oder Methode injiziert werden, die wir im weiteren Verlauf verwenden werden.

Importieren Sie die erforderlichen Namespaces am Anfang der Datei.

using Vonage;
using Vonage.Messaging;
using Vonage.Request;

Registrieren Sie den VonageClient in der Servicesammlung.

builder.Services.AddSingleton<VonageClient>(provider =>
{
    var config = provider.GetRequiredService<IConfiguration>();
    var key = config.GetValue<string>("Vonage_key");
    var secret = config.GetValue<string>("Vonage_Secret");
    var credentials = Credentials.FromApiKeyAndSecret(key, secret);

    return new VonageClient(credentials);
});

Wenn wir Zeile für Zeile gehen, sehen wir, dass wir eine Instanz von IConfiguration erhalten, die uns den Zugriff auf die benötigten App-Einstellungen ermöglicht. Der Schlüssel und das Geheimnis werden dann von der Konfiguration abgerufen, so dass wir Anmeldeinformationen erstellen können, die vom Konstruktor des VonageClient benötigt werden.

Versenden einer SMS

Nachdem wir nun unsere VonageClient-Klasse konfiguriert haben und bereit sind, sie zu injizieren, erstellen wir einen neuen Endpunkt, an den wir Anfragen senden können. Wir müssen ein Datenmodell an den Endpunkt übergeben, also erstellen wir eine Klasse in einer neuen Datei namens "SMSModel". Innerhalb der Klasse fügen wir dann die folgenden Eigenschaften hinzu.

public class SmsModel
{
    public string To { get;set; }

    public string From { get;set; }

    public string Text { get;set; }
}

Nachdem wir unser Modell erstellt haben, können wir nun eine neue POST-Methode mit dem VonageClient und unserer SmsModel-Klasse als Parameter hinzufügen.

app.MapPost("/sms", async (VonageClient vonageClient, SmsModel smsModel) =>
{
    var smsResponse = await vonageClient.SmsClient.SendAnSmsAsync(new SendSmsRequest
    {
        To = smsModel.To,
        From = smsModel.From,
        Text = smsModel.Text
    });
});

In diesem Codeblock sind mehrere Dinge zu beachten. Erstens verwenden wir die MapPost Erweiterungsmethode, um einen Endpunkt auf http://localhost:5000/sms zu erstellen. Zweitens deklarieren wir die Parameter für die Methode; VonageClient wird mit Hilfe der Abhängigkeitsinjektion, die wir zuvor eingerichtet haben, injiziert, SmsModel wird unter Verwendung des Körpers der Anfrage mit Hilfe von Modellbindung.

Im Hauptteil der Methode wird die eigentliche Arbeit des Versendens der SMS erledigt. Wir erstellen eine Instanz von SendSmsRequest mit den Daten aus dem Modell, das wir übergeben haben, und übergeben dann die Anforderungsklasse an die SendAnSmsAsync Methode zu übergeben. Im Sinne von "minimal" ist dies nur eine Zeile!

Probieren Sie es aus

Das Projekt sollte nun erstellt, ausgeführt und Anfragen empfangen werden. Wie bereits erwähnt, haben wir jedoch keine Benutzeroberfläche, um dies auf einfache Weise zu testen. Daher werden wir einige weitere Codezeilen hinzufügen, um die Swagger-Benutzeroberfläche in unser Projekt zu implementieren.

Unmittelbar nach var builder = WebApplication.CreateBuilder(args) müssen wir zwei Codezeilen hinzufügen. Diese fügen die erforderlichen Dienste zu dependency inject hinzu.

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

Wenn diese hinzugefügt sind, registrieren wir die Swagger-Middleware vor der app.Run() Zeile

app.UseSwagger();
app.UseSwaggerUI();
app.Run();

Da wir nun unseren Code geschrieben haben, können wir das Projekt starten. Drücken Sie F5, wenn Sie Visual Studio verwenden, oder führen Sie den folgenden Befehl im Projektordner aus

dotnet run

Wechseln Sie nun zu https://localhost:5001/swagger und Sie sollten in der Lage sein, die Schaltfläche "Try it out" am SMS-Endpunkt zu verwenden. Dort sehen Sie einen Antwortcode 200 und erhalten eine Textnachricht.

Validierung

Die Validierung von Eingaben ist ein wichtiger Bestandteil jeder API. Derzeit ist in Minimal APIs keine Validierung eingebaut, wie man sie bei ASP.NET MVC finden würde. Damian Edwards hat eine kleine Bibliothek namens MinimalValidierung erstellt, die Validierungsattribute ähnlich der MVC-Validierung verwendet.

Ich persönlich bevorzuge Fließende Validierung da es Code zur Definition von Regeln anstelle von Attributen verwendet. Ein Beispiel dafür finden Sie unten, den vollständigen Code einschließlich Validierung finden Sie im Repository auf GitHub.

Dienstregistrierung und Endpunktänderungen

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// validation
builder.Services.AddValidatorsFromAssemblyContaining<SmsModel>(ServiceLifetime.Scoped);

...
 
app.MapPost("/sms", async (VonageClient vonageClient, SmsModel smsModel, IValidator<SmsModel> validator) =>
{
    ValidationResult validationResult =validator.Validate(smsModel);
    if (!validationResult.IsValid)
    {
        return Results.ValidationProblem(validationResult.ToDictionary());
    }

    var smsResponse = await vonageClient.SmsClient.SendAnSmsAsync(new SendSmsRequest
    {
        To = smsModel.To,
        From = smsModel.From,
        Text = smsModel.Text
    });

    return Results.Ok();
});

Modell-Validierer

public class SmsModel
{
    public string To { get; set; }
    public string From { get; set; }
    public string Text { get; set; }

    public class Validator : AbstractValidator<SmsModel>
    {
        public Validator()
        {
            RuleFor(x => x.To).NotEmpty().WithMessage("To phone number required");
            RuleFor(x => x.From).NotEmpty().WithMessage("From phone number required");
        }
    }
}

Erweiterung der Validierung

public static class ValidationExtensions
{
    public static IDictionary<string, string[]> ToDictionary(this ValidationResult validationResult)
       => validationResult.Errors
               .GroupBy(x => x.PropertyName)
               .ToDictionary(
                   g => g.Key,
                   g => g.Select(x => x.ErrorMessage).ToArray()
               );
}

Abschließende Überlegungen

MVC ist zwar ein vollwertiges Framework mit integrierter Modellbindung und -validierung, erweiterbaren Pipelines über Filter, konventions- und deklarationsbasiertem Verhalten und mehr. Manche benötigen bestimmte Funktionen nicht oder haben Leistungseinschränkungen, die den Einsatz von MVC nicht wünschenswert machen. Da immer mehr Funktionen als ASP.NET Core-Middleware (Autorisierung, Authentifizierung, Routing usw.) auftauchen, bringen ASP.NET 6 und Minimal APIs diese Funktionen mit weniger Aufwand ins Spiel und eignen sich perfekt für die zeitnahe und wartbare Erstellung leichtgewichtiger Microservices.

Ressourcen

• Der gesamte Code dieses Tutorials ist zu finden auf GitHub

• Microsoft Minimal APIs Übersicht

• David Fowler's Gist Minimale APIs im Überblick

• Was die Leute Tweet über Minimal-APIs

• Vonage-SMS-API