Built on top of Minimal APIs and easy to use

Add the package to your ASP.NET Core project

dotnet add package EndpointMapper # To add support for OpenAPI (See below for more instructions) dotnet add package EndpointMapper.OpenApi

• .NET 8
• ASP.NET Core 8

Add this into the Program.cs

app.MapEndpointMapperEndpoints();

Then create a public class that implements IEndpoint and add a static method with attribute HttpMap(HttpMapMethod.Get, "<route>") where you can change HttpMapMethod.Get to any other options for different HTTP verbs and "<route>" to one, or more, routes to map the endpoint to

Program.cs:

using EndpointMapper; var builder = WebApplication.CreateBuilder(args); var app = builder.Build(); app.MapEndpointMapperEndpoints(); app.Run();

Then create a file, in this case it's in the root of the project but it could be in any folder

ExampleEndpoint.cs:

using EndpointMapper; public class ExampleEndpoint : IEndpoint { [HttpMap(HttpMapMethod.Get, "/example")] public static Ok<string> Handle() { return TypedResults.Ok("Hello world from EndpointMapper"); } }

Since EndpointMapper uses the native ASP.NET mapping system to map your endpoint and make them work, you can threat your method like the inline delegate to the app.MapGet(...) method.

So you can do:

• Http Body, Query, Route, Headers binding into the function arguments
• Dependency Injection from the method parameters
• Attributes like [FromBody] or [FromQuery] to explicitly map the required values into arguments
• Return using the Results or TypedResults methods or directly a string or any other values that ASP.NET automatically can translate into a valid HTTP response body

An example of this can be seen in the example where TypedResults is used to send an 200 Status code response back with a body attached that contains a string saying Hello world from EndpointMapper

EndpointMapper only supports Swashbuckle.AspNetCore, and you will need to add the EndpointMapper.OpenApi package

You will need to add:

• To your .csproj

  • <GenerateDocumentationFile>true</GenerateDocumentationFile> to generate the XML file to use
  • Optionally, <NoWarn>$(NoWarn);CS1591</NoWarn> to disable the warning Missing XML comment for publicly visible type or member 'Type_or_Member'

• To the .AddSwaggerGen() call

// Get the XML file path from the Assembly var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml"; // Add the comments into the generation for the OpenApi scheme config.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, xmlFilename), includeControllerXmlComments: true);

If you have authentication in your application you need to let swagger know how to authenticate against it, you will need to add to the .AddSwaggerGen() call the registration of Security Definition and if you use the ASP.NET [Authorize] attribute you may also need to add some code to detect the attribute and add the requirement

EndpointMapper.OpenApi provides you an operation filter to add those requirements automatically when it detects the [Authorize] attribute, if you manually check for authentication using a Filter or something else then this is not needed, and you will need something else to add the requirements

The only code you will need to add to your .AddSwaggerGen() call is the following

// Add the security definition with name Bearer and the following options config.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme { Name = "Bearer JWT", Type = SecuritySchemeType.Http, In = ParameterLocation.Header, Scheme = "Bearer" }); // Add the operationFilter to add the authentication requirements where needed config.OperationFilter<AuthenticationRequirementOperationFilter>();

This is an example call to the .AddSwaggerGen() method witch has both XML comments integration and user authentication

This call is here to help you understand the code snippet(s) in the context of the whole call, you may not copy-paste all the function as (especially the authentication stuff) it requires edits based on your application needs, if you want more context you can refer to the EndpointMapper.TestApplication/Program.cs file

// builder is the variable assigned to the return value of "WebApplication.CreateBuilder()" builder.Services.AddSwaggerGen(config => { // Add the security definition with name Bearer and the following options config.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme { Name = "Bearer JWT", Type = SecuritySchemeType.Http, In = ParameterLocation.Header, Scheme = "Bearer" }); // Add the operationFilter to add the authentication requirements where needed config.OperationFilter<AuthenticationRequirementOperationFilter>(); // Get the XML file path from the Assembly var xmlFilename = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml"; // Add the comments into the generation for the OpenApi scheme config.IncludeXmlComments(Path.Combine(AppContext.BaseDirectory, xmlFilename), includeControllerXmlComments: true); });

In previous versions EndpointMapped used to have an option to prefix all the routes. Now this options doesn't exist anymore, see the upgrade guide.

To still have the ability to prefix all your routes by using an ASP.NET Route Group, EndpointMapped used to use it under the hood but now you have to use it yourself.

You can create a Route group by using the MapGroup method on the WebApplication or another route group, then you can use the MapEndpointMapperEndpoints method on the Route group builder instance. If you wanted to configure the group you can now simply use the Route group builder instance you just got.

This now allows to map multiple times your endpoints if you want, for example you could map all your endpoints to both /api and / if you wanted.

You may want to configure more some of your endpoints, but there is a problem. Since we are using Attributes to map our endpoints and ASP.NET Core doesn't provide attribute to specify a filter attribute, for example, for a minimal API it seems that we can't do much about this.

For this reason EndpointMapper allows you to specify a Configure method by implementing the IConfigureEndpoint, this method gives you access to the RouteHandlerBuilder, the route the endpoint is being mapped to and the HTTP Method, this way you can use the builder like if you were chaining methods to the result of MapGet, MapPost, ecc..

If you don't like using attributes to map your endpoints you can implement the IRegisterEndpoint interface and the Register method. In this method you have access to the IEndpointRouteBuilder you use to call the MapEndpointMapperEndpoints method, using the builder you can use the extension methods that ASP.NET Core declares to map all your endpoints, an example is the MapGet or MapPost method.

In the prerelease 3 the public API of EndpointMapper changed quite a bit, so here are all the changes that have been made and you have to do to update your project.

• HttpMap<HttpVerb>(<routes>) has now been replaced with HttpMap(HttpMapMethod.<HttpVerb>, <routes>), so a HttpMapGet("/myRoute") now is HttpMap(HttpMapMethod.Get, "/myRoute")
• All your methods that have an HttpMap attribute now needs to be static
• The constructor based DI is no longer supported. You now need to use the DI from the method parameters
• The Configure method now has only 1 overload, Configure(RouteHandlerBuilder, string route, string method)
• the IEndpointConfigurationAttribute interface and the Filter<T> attribute have been deleted. You now need to use the method based configuration
• AddEndpointMapper<T>(this IServiceCollection, Action<EndpointMapperConfiguration>), AddEndpointMapper(this IServiceCollection, Action<EndpointMapperConfiguration>, params Type[]) and AddEndpointMapper(this IServiceCollection, Action<EndpointMapperConfiguration>, params Assembly[]) have been removed.
• UseEndpointMapper(this WebApplication, bool) has been renamed to MapEndpointMapperEndpoints(this IEndpointRouteBuilder)
• You need .NET 8 and ASP.NET Core 8
• The finding of your endpoints is now done at compile time via a source generator and not a runtime using reflection. Now EndpointMapper is NativeAOT friendly.
• The LogTimeTookToInitialize option doesn't exist anymore
• The RoutePrefix and ConfigureGroupBuilder options do not exist anymore. You can still configure EndpointMapper to use a route prefix using a ASP.NET Route Group

To see all the changes that have been made to the EndpointMapper since v1 code you can check the Github commits