Carter

Charretier

Carter est un framework qui constitue une fine couche de méthodes et de fonctionnalités d'extension sur ASP.NET Core permettant au code d'être plus explicite et surtout plus agréable.

Pour une meilleure compréhension, examinez attentivement les exemples contenus dans ce dépôt. Les exemples démontrent l’utilisation d’extensions élégantes autour des types ASP.NET Core courants, comme indiqué ci-dessous.

Les autres extensions incluent :

• Validate<T> / ValidateAsync<T> - Extensions FluentValidation pour valider les requêtes HTTP entrantes qui ne sont pas disponibles avec les API ASP.NET Core Minimal.
• BindFile/BindFiles/BindFileAndSave/BindFilesAndSave - Vous permet d'accéder facilement à un ou plusieurs fichiers qui ont été téléchargés. Vous pouvez également appeler BindFilesAndSave et cela l'enregistrera dans un chemin que vous spécifiez.
• Routes à utiliser dans les middlewares ASP.NET Core courants, par exemple app.UseExceptionHandler("/errorhandler"); .
• IResponseNegotiator vous permettent de définir l'apparence de la réponse sur un certain en-tête Accept (négociation de contenu). La gestion de JSON est intégrée à la réponse par défaut, mais l'implémentation d'une interface permet à l'utilisateur de choisir comment il souhaite représenter les ressources.
• Toutes les implémentations d’interface pour les composants Carter sont automatiquement enregistrées dans ASP.NET Core DI. Implémentez l’interface et c’est parti.

Sorties

• Dernière version de NuGet
• Dernière pré-version de NuGet
• Dernière version de CI
• Statut de construction

Rejoignez notre chaîne Slack

Routage

Carter utilise le routage IEndpointRouteBuilder et toutes les extensions proposées par IEndpointConventionBuilder également connues sous le nom d'API minimales. Par exemple, vous pouvez définir un itinéraire avec autorisation requise comme ceci :

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

D'où vient le nom "Carter" ?

Je suis un grand fan et un contributeur principal de Nancy, le meilleur framework Web .NET, depuis de nombreuses années, et le nom "Nancy" est né du fait qu'il est inspiré de Sinatra, le framework Web Ruby. Frank Sinatra avait une fille appelée Nancy et c'est de là que ça vient.

J'essayais aussi de penser à un nom dérivé, et j'avais récemment écouté la chanson Empire State of Mind dans laquelle Jay-Z déclare qu'il est le nouveau Sinatra. Son vrai nom est Shaun Carter donc j'ai pris Carter et nous y voilà !

Constructions CI

Si vous souhaitez essayer les dernières versions de la branche master, ajoutez https://f.feedz.io/carter/carter/nuget/index.json à votre NuGet.config et récupérez la dernière et la meilleure version de Carter.

Commencer

Vous pouvez commencer à utiliser le modèle ou en ajoutant manuellement le package à une application nouvelle ou existante.

Modèle

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

1. Installez le modèle - dotnet new install CarterTemplate

2. Créez une nouvelle application à l'aide du modèle - dotnet new carter -n MyCarterApp -o MyCarterApp

3. Allez dans le nouveau répertoire créé pour l'application cd MyCarterApp

4. Exécutez l'application - dotnet run

Emballer

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

1. Créer une nouvelle application ASP.NET Core vide - dotnet new web -n MyCarterApp

2. Accédez au nouvel emplacement du projet - cd ./MyCarterApp

3. Ajouter le package Carter - dotnet add package carter

4. Modifiez votre Program.cs pour utiliser Carter

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

var app = builder . Build ( ) ;

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

5. Créer un nouveau module

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

6. Exécutez l'application - dotnet run

Échantillon

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

Plus d'échantillons

Configuration

Comme mentionné précédemment, Carter recherchera les implémentations dans votre application et les enregistrera pour DI. Cependant, si vous souhaitez une application plus contrôlée, Carter est livré avec un CarterConfigurator qui vous permet d'enregistrer manuellement les modules, les validateurs et les négociateurs de réponses.

Carter utilisera un négociateur de réponse basé sur System.Text.Json , bien qu'il fournisse des implémentations personnalisées via l'interface IResponseNegotiator . Pour utiliser votre propre implémentation de IResponseNegotiator (par exemple, CustomResponseNegotiator ), ajoutez la ligne suivante à la configuration initiale de Carter, dans ce cas dans le cadre de Program.cs :

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

Là encore, Carter est déjà livré avec un négociateur de réponses utilisant Newtonsoft.Json , vous pouvez donc câbler l'implémentation de Newtonsoft avec la ligne suivante :

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