Carter

Fuhrmann

Carter ist ein Framework, das eine dünne Schicht von Erweiterungsmethoden und -funktionen über ASP.NET Core darstellt und den Code expliziter und vor allem unterhaltsamer macht.

Schauen Sie sich zum besseren Verständnis die Beispiele in diesem Repo genau an. Die Beispiele veranschaulichen die Verwendung eleganter Erweiterungen rund um gängige ASP.NET Core-Typen, wie unten gezeigt.

Weitere Erweiterungen sind:

• Validate<T> / ValidateAsync<T> – FluentValidation-Erweiterungen zur Validierung eingehender HTTP-Anfragen, die mit ASP.NET Core Minimal APIs nicht verfügbar sind.
• BindFile/BindFiles/BindFileAndSave/BindFilesAndSave – Ermöglicht Ihnen den einfachen Zugriff auf eine oder mehrere hochgeladene Dateien. Alternativ können Sie BindFilesAndSave aufrufen und es dann unter einem von Ihnen angegebenen Pfad speichern.
• Routen zur Verwendung in allgemeiner ASP.NET Core-Middleware, z. B. app.UseExceptionHandler("/errorhandler"); .
• Mit IResponseNegotiator können Sie definieren, wie die Antwort auf einem bestimmten Accept-Header (Inhaltsverhandlung) aussehen soll. Die Handhabung von JSON ist in der Standardantwort integriert, aber durch die Implementierung einer Schnittstelle kann der Benutzer auswählen, wie er Ressourcen darstellen möchte.
• Alle Schnittstellenimplementierungen für Carter-Komponenten werden automatisch in ASP.NET Core DI registriert. Implementieren Sie die Schnittstelle und los geht's.

Veröffentlichungen

• Neueste NuGet-Version
• Neueste NuGet-Vorabversion
• Neueste CI-Version
• Build-Status

Treten Sie unserem Slack-Kanal bei

Routenführung

Carter verwendet IEndpointRouteBuilder Routing und alle IEndpointConventionBuilder angebotenen Erweiterungen, die auch als Minimal-APIs bezeichnet werden. Sie können beispielsweise eine Route mit erforderlicher Autorisierung wie folgt definieren:

app . MapGet ( " / " , ( ) => " There's no place like 127.0.0.1 " ) . RequireAuthorization ( ) ;

Woher kommt der Name „Carter“?

Ich bin seit vielen Jahren ein großer Fan und maßgeblicher Mitwirkender von Nancy, dem besten .NET-Webframework, und der Name „Nancy“ entstand, weil er von Sinatra, dem Ruby-Webframework, inspiriert wurde. Frank Sinatra hatte eine Tochter namens Nancy und daher kam es.

Ich habe auch versucht, mir einen abgeleiteten Namen auszudenken, und habe kürzlich das Lied „Empire State of Mind“ gehört, in dem Jay-Z erklärt, er sei der neue Sinatra. Sein richtiger Name ist Shaun Carter, also habe ich Carter mitgenommen und hier sind wir!

CI-Builds

Wenn Sie die neuesten Builds aus dem Master-Zweig ausprobieren möchten, fügen Sie https://f.feedz.io/carter/carter/nuget/index.json zu Ihrer NuGet.config hinzu und holen Sie sich die neueste und beste Version von Carter.

Erste Schritte

Sie können entweder mit der Vorlage beginnen oder das Paket manuell zu einer neuen oder vorhandenen Anwendung hinzufügen.

Vorlage

https://www.nuget.org/packages/CarterTemplate/

1. Installieren Sie die Vorlage – dotnet new install CarterTemplate

2. Erstellen Sie eine neue Anwendung mit der Vorlage „ dotnet new carter -n MyCarterApp -o MyCarterApp

3. Gehen Sie in das neue Verzeichnis, das für die Anwendungs- cd MyCarterApp erstellt wurde

4. Führen Sie die Anwendung aus – dotnet run

Paket

https://www.nuget.org/packages/Carter

1. Erstellen Sie eine neue leere ASP.NET Core-Anwendung – dotnet new web -n MyCarterApp

2. Wechseln Sie in den neuen Projektspeicherort – cd ./MyCarterApp

3. Carter-Paket hinzufügen – dotnet add package carter

4. Ändern Sie Ihre Program.cs, um Carter zu verwenden

 var builder = WebApplication . CreateBuilder ( args ) ;
builder . Services . AddCarter ( ) ;

var app = builder . Build ( ) ;

app . MapCarter ( ) ;
app . Run ( ) ;

5. Erstellen Sie ein neues Modul

    public class HomeModule : ICarterModule
    {
        public void AddRoutes ( IEndpointRouteBuilder app )
        {
            app . MapGet ( " / " , ( ) => " Hello from Carter! " ) ;
        }
    }

6. Führen Sie die Anwendung aus – dotnet run

Probe

 var builder = WebApplication . CreateBuilder ( args ) ;
builder . Services . AddSingleton < IActorProvider , ActorProvider > ( ) ;
builder . Services . AddCarter ( ) ;

var app = builder . Build ( ) ;

app . MapCarter ( ) ;
app . Run ( ) ;

public class HomeModule : ICarterModule
{
    public void AddRoutes ( IEndpointRouteBuilder app )
    {
        app . MapGet ( " / " , ( ) => " Hello from Carter! " ) ;
        app . MapGet ( " /qs " , ( HttpRequest req ) =>
        {
            var ids = req . Query . AsMultiple < int > ( " ids " ) ;
            return $" It's { string . Join ( " , " , ids ) } " ;
        } ) ;
        app . MapGet ( " /conneg " , ( HttpResponse res ) => res . Negotiate ( new { Name = " Dave " } ) ) ;
        app . MapPost ( " /validation " , HandlePost ) ;
    }

    private IResult HandlePost ( HttpContext ctx , Person person , IDatabase database )
    {
        var result = ctx . Request . Validate ( person ) ;

        if ( ! result . IsValid )
        {
            return Results . UnprocessableEntity ( result . GetFormattedErrors ( ) ) ;
        }

        var id = database . StorePerson ( person ) ;

        ctx . Response . Headers . Location = $" / { id } " ;
        return Results . StatusCode ( 201 ) ;
    }
}

public record Person ( string Name ) ;

public interface IDatabase
{
    int StorePerson ( Person person ) ;
}

public class Database : IDatabase
{
    public int StorePerson ( Person person )
    {
        //db stuff
    }
}

Weitere Beispiele

Konfiguration

Wie bereits erwähnt, sucht Carter nach Implementierungen in Ihrer App und registriert sie für DI. Wenn Sie jedoch eine besser kontrollierte App wünschen, verfügt Carter über einen CarterConfigurator , mit dem Sie Module, Validatoren und Antwortverhandler manuell registrieren können.

Carter wird einen Antwort-Negotiator verwenden, der auf System.Text.Json basiert, obwohl er benutzerdefinierte Implementierungen über die IResponseNegotiator -Schnittstelle bereitstellt. Um Ihre eigene Implementierung von IResponseNegotiator (z. B. CustomResponseNegotiator ) zu verwenden, fügen Sie die folgende Zeile zur anfänglichen Carter-Konfiguration hinzu, in diesem Fall als Teil von Program.cs :

    builder . Services . AddCarter ( configurator : c =>
    {
        c . WithResponseNegotiator < CustomResponseNegotiator > ( ) ;
        c . WithModule < MyModule > ( ) ;
        c . WithValidator < TestModelValidator > ( )
    } ) ;

Auch hier liefert Carter bereits einen Response Negotiator aus, Newtonsoft.Json verwendet, sodass Sie die Newtonsoft-Implementierung mit der folgenden Zeile vernetzen können:

    builder . Services . AddCarter ( configurator : c =>
    {
        c . WithResponseNegotiator < NewtonsoftJsonResponseNegotiator > ( ) ;
    } ) ;