Carter

Carter

Carter é uma estrutura que é uma fina camada de métodos de extensão e funcionalidades sobre o ASP.NET Core, permitindo que o código seja mais explícito e, o mais importante, mais agradável.

Para um melhor entendimento, dê uma boa olhada nos exemplos deste repositório. Os exemplos demonstram o uso de extensões elegantes em torno de tipos comuns do ASP.NET Core, conforme mostrado abaixo.

Outras extensões incluem:

• Validate<T> / ValidateAsync<T> – Extensões FluentValidation para validar solicitações HTTP recebidas que não estão disponíveis com APIs ASP.NET Core Minimal.
• BindFile/BindFiles/BindFileAndSave/BindFilesAndSave - Permite que você obtenha acesso facilmente a um arquivo/arquivos que foram carregados. Alternativamente, você pode chamar BindFilesAndSave e isso o salvará em um caminho que você especificar.
• Rotas para usar em middleware ASP.NET Core comum, por exemplo, app.UseExceptionHandler("/errorhandler"); .
• IResponseNegotiator s permitem definir como a resposta deve ser exibida em um determinado cabeçalho Accept (negociação de conteúdo). O tratamento de JSON é integrado na resposta padrão, mas a implementação de uma interface permite que o usuário escolha como deseja representar os recursos.
• Todas as implementações de interface para componentes Carter são registradas automaticamente no ASP.NET Core DI. Implemente a interface e pronto.

Lançamentos

• Versão mais recente do NuGet
• Último pré-lançamento do NuGet
• Lançamento de CI mais recente
• Status de construção

Junte-se ao nosso canal Slack

Roteamento

Carter usa roteamento IEndpointRouteBuilder e todas as extensões que IEndpointConventionBuilder oferece, também conhecidas como APIs mínimas. Por exemplo, você pode definir uma rota com autorização necessária da seguinte forma:

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

De onde vem o nome "Carter"?

Tenho sido um grande fã e contribuidor principal do Nancy, o melhor framework web .NET, por muitos anos, e o nome "Nancy" surgiu devido ao fato de ter sido inspirado no Sinatra, o framework web Ruby. Frank Sinatra tinha uma filha chamada Nancy e foi daí que veio.

Eu também estava tentando pensar em um nome derivado e ouvi recentemente a música Empire State of Mind, onde Jay-Z declara que é o novo Sinatra. O nome verdadeiro dele é Shaun Carter, então peguei Carter e aqui estamos!

Construções de CI

Se você quiser experimentar as compilações mais recentes do branch master, adicione https://f.feedz.io/carter/carter/nuget/index.json ao seu NuGet.config e obtenha a melhor e mais recente versão do Carter.

Começando

Você pode começar usando o modelo ou adicionando o pacote manualmente a um aplicativo novo ou existente.

Modelo

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

1. Instale o modelo - dotnet new install CarterTemplate

2. Crie um novo aplicativo usando o modelo - dotnet new carter -n MyCarterApp -o MyCarterApp

3. Entre no novo diretório criado para o aplicativo cd MyCarterApp

4. Execute o aplicativo - dotnet run

Pacote

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

1. Crie um novo aplicativo ASP.NET Core vazio - dotnet new web -n MyCarterApp

2. Mude para o novo local do projeto - cd ./MyCarterApp

3. Adicionar pacote Carter - dotnet add package carter

4. Modifique seu Program.cs para usar Carter

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

var app = builder . Build ( ) ;

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

5. Crie um novo módulo

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

6. Execute o aplicativo - dotnet run

Amostra

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

Mais amostras

Configuração

Conforme mencionado anteriormente, Carter irá procurar implementações em seu aplicativo e registrá-las para DI. Porém, se você deseja um aplicativo mais controlado, Carter vem com um CarterConfigurator que permite registrar módulos, validadores e negociadores de resposta manualmente.

Carter usará um negociador de resposta baseado em System.Text.Json , embora forneça implementações personalizadas por meio da interface IResponseNegotiator . Para usar sua própria implementação de IResponseNegotiator (digamos, CustomResponseNegotiator ), adicione a seguinte linha à configuração inicial do Carter, neste caso como parte de Program.cs :

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

Aqui, novamente, Carter já vem com um negociador de resposta usando Newtonsoft.Json , então você pode conectar a implementação do Newtonsoft com a seguinte linha:

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