Carter

Carretero

Carter es un marco que es una capa delgada de métodos de extensión y funcionalidad sobre ASP.NET Core, lo que permite que el código sea más explícito y, lo más importante, más agradable.

Para una mejor comprensión, observe detenidamente los ejemplos dentro de este repositorio. Los ejemplos demuestran usos de extensiones elegantes en torno a tipos comunes de ASP.NET Core, como se muestra a continuación.

Otras extensiones incluyen:

• Validate<T> / ValidateAsync<T> : extensiones FluentValidation para validar solicitudes HTTP entrantes que no están disponibles con las API mínimas de ASP.NET Core.
• BindFile/BindFiles/BindFileAndSave/BindFilesAndSave : le permite acceder fácilmente a un archivo o archivos que se han subido. Alternativamente, puede llamar a BindFilesAndSave y esto lo guardará en la ruta que especifique.
• Rutas para usar en middleware ASP.NET Core común, por ejemplo, app.UseExceptionHandler("/errorhandler"); .
• Los IResponseNegotiator le permiten definir cómo debe verse la respuesta en un determinado encabezado de aceptación (negociación de contenido). El manejo de JSON está integrado en la respuesta predeterminada, pero la implementación de una interfaz permite al usuario elegir cómo quiere representar los recursos.
• Todas las implementaciones de interfaz para los componentes de Carter se registran automáticamente en ASP.NET Core DI. Implemente la interfaz y listo.

Lanzamientos

• Última versión de NuGet
• Último prelanzamiento de NuGet
• Última versión de CI
• Estado de construcción

Únase a nuestro canal Slack

Enrutamiento

Carter utiliza el enrutamiento IEndpointRouteBuilder y todas las extensiones que ofrece IEndpointConventionBuilder también conocidas como API mínimas. Por ejemplo, puede definir una ruta con autorización requerida de esta manera:

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

¿De dónde viene el nombre "Carter"?

He sido un gran admirador y colaborador principal de Nancy, el mejor marco web .NET, durante muchos años, y el nombre "Nancy" surgió debido a que se inspiró en Sinatra, el marco web Ruby. Frank Sinatra tuvo una hija llamada Nancy y de ahí vino.

También estaba tratando de pensar en un nombre derivado, y recientemente había escuchado la canción Empire State of Mind donde Jay-Z declara que es el nuevo Sinatra. Su verdadero nombre es Shaun Carter, así que tomé a Carter y ¡aquí estamos!

Construcciones de CI

Si desea probar las últimas compilaciones de la rama maestra, agregue https://f.feedz.io/carter/carter/nuget/index.json a su NuGet.config y obtenga la última y mejor versión de Carter.

Empezando

Puede comenzar a utilizar la plantilla o agregar el paquete manualmente a una aplicación nueva o existente.

Plantilla

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

1. Instale la plantilla: dotnet new install CarterTemplate

2. Cree una nueva aplicación usando la plantilla: dotnet new carter -n MyCarterApp -o MyCarterApp

3. Vaya al nuevo directorio creado para el cd MyCarterApp

4. Ejecute la aplicación - dotnet run

Paquete

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

1. Cree una nueva aplicación ASP.NET Core vacía: dotnet new web -n MyCarterApp

2. Cambie a la nueva ubicación del proyecto: cd ./MyCarterApp

3. Agregar paquete Carter - dotnet add package carter

4. Modifique su Program.cs para usar Carter

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

var app = builder . Build ( ) ;

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

5. Crear un nuevo módulo

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

6. Ejecute la aplicación - dotnet run

Muestra

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

Más muestras

Configuración

Como se mencionó anteriormente, Carter buscará implementaciones en su aplicación y las registrará para DI. Sin embargo, si desea una aplicación más controlada, Carter viene con un CarterConfigurator que le permite registrar módulos, validadores y negociadores de respuesta manualmente.

Carter utilizará un negociador de respuestas basado en System.Text.Json , aunque proporciona implementaciones personalizadas a través de la interfaz IResponseNegotiator . Para utilizar su propia implementación de IResponseNegotiator (por ejemplo, CustomResponseNegotiator ), agregue la siguiente línea a la configuración inicial de Carter, en este caso como parte de Program.cs :

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

Aquí nuevamente, Carter ya viene con un negociador de respuesta que usa Newtonsoft.Json , por lo que puede conectar la implementación de Newtonsoft con la siguiente línea:

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