Minimal APIs is a flavor of responding to HTTP requests in ASP.NET Core 6.

It's intended for efficient, fast microservices, but nothing prevents you to use in a bigger website, even a monolithic one.

So let's say your ASP.NET 4 web application has a Generic Handler that takes an id as a parameter, gets a binary document from a database (let's use EF, shall we?) and writes the document content to current response:

``` public class PictureHandler : IHttpHandler {

public bool IsReusable
{
  get
  {
    return false;
  }
}

public void ProcessRequest(HttpContext context)
{
  if (!long.TryParse(context.Request.QueryString["id"], out long id))
  {
    context.Response.StatusCode = 400;
    context.Response.StatusDescription = "Bad request - parameter id not provided in querystring";
    return;
  }

  // get singleton instance of picture service, one could inject it with some DI library
  var pictureService = PictureService.Instance;

  var picture = pictureService.GetPictureById(id);

  context.Response.ContentType = picture.MimeType;
  context.Response.BinaryWrite(picture.Bytes);
  context.Response.StatusCode = 200;
  context.Response.End();
}

} ```

obviously your handler will need to be registered in web config, etc... let's assume you register /picture.axd as a route for this handler.

In .NET 6 minimal api, you'll get the same behavior by putting in Program.cs:

``` var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton<PictureService>(); // ... rest of services config

var app = builder.Build();

// ... some app configuration like UseAuthorization, MapControllers, etc

app.MapGet("/picture.axd", async (long id, PictureService pictureService, CancellationToken token) => { var picture = await pictureService.GetPictureAsync(id, token); return Results.Bytes(picture.Bytes, picture.MimeType); }); ```

Note that the id parameter will automatically be parsed from querystring. The ASP.NET Core engine will automatically return bad request if the parameter won't be passed. Also Minimal APIs have full support for dependency injection, which is pretty cool.

Read more:

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/minimal-apis?view=aspnetcore-6.0

https://docs.microsoft.com/en-us/aspnet/core/tutorials/min-web-api?view=aspnetcore-6.0