Skip to content
Carter is framework that is a thin layer of extension methods and functionality over ASP.NET Core allowing code to be more explicit and most importantly more enjoyable.
C#
Branch: master
Clone or download
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
.github Update FUNDING.yml May 30, 2019
media
samples Use async json serialization (#218) Nov 26, 2019
src/Carter Use async json serialization (#218) Nov 26, 2019
template 5.0.0 Nov 25, 2019
test Use async json serialization (#218) Nov 26, 2019
.gitignore Make openapi models point to 'components' and generate openapi constr… Feb 6, 2019
Carter.sln OpenAPI Changes (#215) Nov 20, 2019
Carter.sln.DotSettings Change module scope so that one per request is created and add Carter… Mar 4, 2019
LICENSE
NuGet.config Upgrade to ASP.Net Core 3 and Endpoint Routing Oct 16, 2019
README.md Update README.md - typos and acronyms(#217) Nov 25, 2019
TEMPLATE.md Renamed Botwin to Carter (#95) Apr 7, 2018
appveyor.yml publish ci feed for pr Oct 16, 2019
global.json update to rtm Oct 16, 2019
slack.svg OpenAPI Changes (#215) Nov 20, 2019

README.md

Carter

NuGet Version

Carter is a framework that is a thin layer of extension methods and functionality over ASP.NET Core allowing the code to be more explicit and most importantly more enjoyable.

Carter simply builds on top of ASP.NET Core allowing you to have more elegant routing rather than attribute routing, convention routing, or ASP.NET Controllers.

For a better understanding, take a good look at the samples inside this repo. The samples demonstrate usages of elegant extensions around common ASP.NET Core types as shown below.

Other extensions include:

  • Bind/BindAndValidate<T> - FluentValidation extensions to validate incoming HTTP requests.

  • BindFile/BindFiles/BindFileAndSave/BindFilesAndSave - Allows you to easily get access to a file/files that has been uploaded. Alternatively you can call BindFilesAndSave and this will save it to a path you specify.

  • Before/After hooks to the routes defined in a Carter module.

  • Routes to use in common ASP.NET Core middleware e.g., app.UseExceptionHandler("/errorhandler");.

  • IStatusCodeHandlers are also an option as the ASP.NET Core UseStatusCodePages middleware is not elegant enough IMO. IStatusCodeHandlers allow you to define what happens when one of your routes returns a specific status code. An example usage is shown in the sample.

  • IResponseNegotiators allow you to define how the response should look on a certain Accept header. Handling JSON is built in the default response but implementing an interface allows the user to choose how they want to represent resources.

  • All interface implementations for Carter components are registered into ASP.NET Core DI automatically. Implement the interface and off you go.

  • Supports two different routing APIs.

    (i)

    this.Get("/actors/{id:int}", async (req, res) =>
    {
        var person = actorProvider.Get(req.RouteValues.As<int>("id"));
        await res.Negotiate(person);
    });

    (ii)

    this.Get("/actors/{id:int}", async (ctx) =>
    {
        var person = actorProvider.Get(ctx.Request.RouteValues.As<int>("id"));
        await ctx.Response.Negotiate(person);
    });

Endpoint Routing

Carter supports endpoint routing and all the extensions IEndpointConventionBuilder offers. For example you can define a route with authorization required like so:

this.Get("/", (req, res) => res.WriteAsync("There's no place like 127.0.0.1")).RequireAuthorization();

OpenApi

Carter supports OpenApi out of the box. Simply call /openapi from your API and you will get a OpenApi JSON response.

To configure your routes for OpenApi simply supply the meta data class on your routes. For example:

this.Get<GetActors>("/actors", async (req, res) =>
{
    var people = actorProvider.Get();
    await res.AsJson(people);
});

The meta data class is the way to document your routes and looks something like this:

public class GetActors : RouteMetaData
{
    public override string Description { get; } = "Returns a list of actors";

    public override RouteMetaDataResponse[] Responses { get; } =
    {
        new RouteMetaDataResponse
        {
            Code = 200,
            Description = $"A list of {nameof(Actor)}s",
            Response = typeof(IEnumerable<Actor>)
        }
    };

    public override string Tag { get; } = "Actors";
}

Where does the name "Carter" come from?

I have been a huge fan of, and core contributor to Nancy, the best .NET web framework, for many years, and the name "Nancy" came about due to it being inspired from Sinatra the Ruby web framework. Frank Sinatra had a daughter called Nancy and so that's where it came from.

I was also trying to think of a derivative name, and I had recently listened to the song Empire State of Mind where Jay-Z declares he is the new Sinatra. His real name is Shaun Carter so I took Carter and here we are!

CI Builds

If you'd like to try the latest builds from the master branch add https://ci.appveyor.com/nuget/carterci to your NuGet.config and pick up the latest and greatest version of Carter.

Getting Started

You can get started using either the template or by adding the package manually to a new or existing application.

Template

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

  1. Install the template - dotnet new -i CarterTemplate

  2. Create a new application using template - dotnet new Carter -n MyCarterApp

  3. Run the application - dotnet run

Package

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

  1. Create a new empty ASP.NET Core application - dotnet new web -n MyCarterApp

  2. Change into the new project location - cd ./MyCarterApp

  3. Add Carter package - dotnet add package carter

  4. Modify your Startup.cs to use Carter

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCarter();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseRouting();
        app.UseEndpoints(builder => builder.MapCarter());
    }
}
  1. Create a new Module
    public class HomeModule : CarterModule
    {
        public HomeModule()
        {
            Get("/", async (req, res) => await res.WriteAsync("Hello from Carter!"));
        }
    }
  1. Run the application - dotnet run

Sample

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddSingleton<IActorProvider, ActorProvider>();
        services.AddCarter();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseRouting();
        app.UseEndpoints(builder => builder.MapCarter());
    }
}

public class ActorsModule : CarterModule
{
    public ActorsModule(IActorProvider actorProvider)
    {
        this.Get("/actors", async (req, res) =>
        {
            var people = actorProvider.Get();
            await res.AsJson(people);
        });

        this.Get("/actors/{id:int}", async (req, res) =>
        {
            var person = actorProvider.Get(req.RouteValues.As<int>("id"));
            await res.Negotiate(person);
        });

        this.Put("/actors/{id:int}", async (req, res) =>
        {
            var result = req.BindAndValidate<Actor>();

            if (!result.ValidationResult.IsValid)
            {
                res.StatusCode = 422;
                await res.Negotiate(result.ValidationResult.GetFormattedErrors());
                return;
            }

            // Update the user in your database

            res.StatusCode = 204;
        });

        this.Post("/actors", async (req, res) =>
        {
            var result = req.BindAndValidate<Actor>();

            if (!result.ValidationResult.IsValid)
            {
                res.StatusCode = 422;
                await res.Negotiate(result.ValidationResult.GetFormattedErrors());
                return;
            }

            // Save the user in your database

            res.StatusCode = 201;
            await res.Negotiate(result.Data);
        });

    }
}

More samples

You can’t perform that action at this time.