Uses of Filters:

• Validate input data
• Log requests and responses
• Check authentication or authorization
• Modify request or response data
• Handle exceptions
• Execute common logic for multiple endpoints

Execution Flow

Client Request
      │
      ▼
Endpoint Filter (Before)
      │
      ▼
Route Handler
      │
      ▼
Endpoint Filter (After)
      │
      ▼
Client Response

How to use filters in Minimal API

We use AddEndpointFilter extension method. To this method we provide a Delegate that fulfills two core roles:

1. It receives the execution context: EndpointFilterInvocationContext
2. It returns the next step in the pipeline: EndpointFilterDelegate

EndpointFilterInvocationContext: Provides direct access to the current request’s HttpContext and exposes an Arguments list.

Arguments List: Contains the arguments passed to the route handler. These arguments are structured in the exact order in which they appear in the handler’s declaration. A classic example is given on official Microsoft docs, check below:

var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

string ColorName(string color) => $"Color specified: {color}!";

app.MapGet("/colorSelector/{color}", ColorName)
    .AddEndpointFilter(async (invocationContext, next) =>
    {
        var color = invocationContext.GetArgument<string>(0);

        if (color == "Red")
        {
            return Results.Problem("Red not allowed!");
        }
        return await next(invocationContext);
    });

app.Run();

Here we have defined the endpoint handler.

string ColorName(string color) => $"Color specified: {color}!";

This is a simple method that accepts a string parameter. If the endpoint executes successfully, it returns:

Color specified: Blue!

or

Color specified: Green!

depending on the URL.

Map the endpoint:

app.MapGet("/colorSelector/{color}", ColorName)

This creates a GET endpoint.

Example URLs:

GET /colorSelector/Blue
GET /colorSelector/Green
GET /colorSelector/Red

The {color} part is a route parameter. For example:

/colorSelector/Blue

binds.

color = "Blue"

and passes it to:

ColorName(color)

Add an Endpoint Filter:

.AddEndpointFilter(async (invocationContext, next) => {}

This attaches a filter only to this endpoint. Think of the execution order like this:

Request
   ↓
Endpoint Filter
   ↓
Endpoint Handler (ColorName)
   ↓
Response

The filter can:

• inspect arguments
• modify arguments
• stop execution
• modify the response

Read the endpoint argument:

var color = invocationContext.GetArgument<string>(0);

invocationContext contains all arguments passed to the endpoint. The endpoint is:

string ColorName(string color)

Its parameters are:

Index 0 → color

So:

GetArgument<string>(0)

returns the route value. If the URL is:

/colorSelector/Blue

then:

color == "Blue"

Validate the value:

if (color == "Red")
{
    return Results.Problem("Red not allowed!");
}

If the client requests:

GET /colorSelector/Red

the filter immediately returns:

Results.Problem(...)

instead of calling the endpoint. The endpoint handler never executes. The client receives a response similar to:

{
    "title": "An error occurred.",
    "detail": "Red not allowed!"
}

Continue to the endpoint:

return await next(invocationContext);

next() calls the next component in the endpoint pipeline. If there are no more filters, it calls:

ColorName(color)

So:

GET /colorSelector/Blue

executes:

ColorName("Blue")

and returns:

Color specified: Blue!

Multiple Endpoint Filters in Minimal API

We can also add multiple Endpoint Filters to Minimal API. Think of them as layers wrapped around the endpoint, much like nested boxes. Check the below code where you notice that the endpoint itself does almost nothing. The interesting part is the filters attached to it.

var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

app.MapGet("/", () =>
    {
        app.Logger.LogInformation("             Endpoint");
        return "Test of multiple filters";
    })
    .AddEndpointFilter(async (efiContext, next) =>
    {
        app.Logger.LogInformation("Before 1st filter");
        var result = await next(efiContext);
        app.Logger.LogInformation("After 1st filter");
        return result;
    })
    .AddEndpointFilter(async (efiContext, next) =>
    {
        app.Logger.LogInformation(" Before 2nd filter");
        var result = await next(efiContext);
        app.Logger.LogInformation(" After 2nd filter");
        return result;
    })
    .AddEndpointFilter(async (efiContext, next) =>
    {
        app.Logger.LogInformation("     Before 3rd filter");
        var result = await next(efiContext);
        app.Logger.LogInformation("     After 3rd filter");
        return result;
    });

app.Run();

Map the endpoint.

app.MapGet("/", () =>
{
    app.Logger.LogInformation("             Endpoint");
    return "Test of multiple filters";
})

This creates a GET endpoint for the root URL (/).

When the endpoint finally executes, it:

• Writes “Endpoint” to the log.
• Returns the string:

Test of multiple filters

First Endpoint Filter:

.AddEndpointFilter(async (efiContext, next) =>
{
    app.Logger.LogInformation("Before 1st filter");

    var result = await next(efiContext);

    app.Logger.LogInformation("After 1st filter");

    return result;
})

This filter runs before the endpoint. Before calling next().

app.Logger.LogInformation("Before 1st filter");

prints:

Before first filter

Call next:

await next(efiContext);

This passes execution to the next filter. After that filter (and eventually the endpoint) finishes, execution comes back here. Then:

app.Logger.LogInformation("After 1st filter");

runs:

Second Endpoint Filter:

.AddEndpointFilter(async (efiContext, next) =>
{
    app.Logger.LogInformation(" Before 2nd filter");

    var result = await next(efiContext);

    app.Logger.LogInformation(" After 2nd filter");

    return result;
})

This behaves exactly like the first filter. It surrounds everything after it.

Third Endpoint Filter:

.AddEndpointFilter(async (efiContext, next) =>
{
    app.Logger.LogInformation("     Before 3rd filter");

    var result = await next(efiContext);

    app.Logger.LogInformation("     After 3rd filter");

    return result;
});

This is the last filter.

Calling:

await next(efiContext);

doesn’t invoke another filter because none remain. Instead, it invokes the endpoint.

Execution Order:

Suppose you request:

GET /

Step 1:

The first filter starts.

Before first filter

It calls:

await next()

Step 2:

The second filter starts.

Before 2nd filter

It calls:

await next()

Step 3:

The third filter starts.

Before 3rd filter

It calls:

await next()

Step 4:

No more filters remain, so the endpoint executes.

Endpoint

The endpoint returns:

Test of multiple filters

Step 5:

Execution returns to the third filter.

After 3rd filter

Step 6:

Execution returns to the second filter.

After 2nd filter

Step 7:

Execution returns to the first filter.

After first filter

Final Log Output:

The logs appear in this order:

Before first filter
 Before 2nd filter
     Before 3rd filter
             Endpoint
     After 3rd filter
 After 2nd filter
After first filter

Validations in Minimal API with Filters

As applications grow, validating incoming requests becomes essential to ensure data integrity, application reliability, and security. One effective way to implement validation in Minimal APIs is by using endpoint filters, which allow developers to intercept requests before they reach the endpoint handler. Endpoint filters enable validation logic to be centralized and reused across multiple endpoints, reducing code duplication and improving maintainability.

The below example performs validation with the help of filters.

app.MapPut("/works/{id}", async (int id, Work work, WorkDb db) =>
{
    var todo = await db.Works.FindAsync(id);

    if (todo is null) return Results.NotFound();

    todo.Name = work.Name;
    todo.TimeStart = work.TimeStart;
    todo.TimeEnd = work.TimeEnd;
    todo.IsComplete = work.IsComplete;

    await db.SaveChangesAsync();

    return Results.NoContent();
}).AddEndpointFilter(async (efiContext, next) =>
{
    var w = efiContext.GetArgument<Work>(1);

    var validationError = Utilities.IsValid(w);

    if (!string.IsNullOrEmpty(validationError))
    {
        return Results.Problem(validationError);
    }
    return await next(efiContext);
});

The Work class code:

public class Work
{
    public int Id { get; set; }
     
    public string Name { get; set; }
 
    public string TimeStart { get; set; }
 
    public string TimeEnd { get; set; }
 
    public bool IsComplete { get; set; }
}

After defining the endpoint, the following code attaches an endpoint filter:

.AddEndpointFilter(async (efiContext, next) =>

An endpoint filter executes before and/or after the endpoint handler. It can:

• validate input
• log requests
• authorize users
• measure execution time
• modify responses

In this example, it performs validation.

Accessing the Request Object.

var w = efiContext.GetArgument<Work>(1);

GetArgument() retrieves one of the endpoint handler’s arguments. Here it retrieves the Work object, since Work is the second parameter.

Validating the Object:

var validationError = Utilities.IsValid(w);

The Utilities.IsValid() method performs custom validation on the Work object.

For example, it might check that:

• Name is not empty.
• TimeStart is earlier than TimeEnd.
• Required fields are present.

It returns:

• an error message if validation fails.
• null or an empty string if validation succeeds.

Returning Validation Errors:

if (!string.IsNullOrEmpty(validationError))
{
    return Results.Problem(validationError);
}

If validation fails, the filter stops the request and returns an HTTP error response containing the validation message.

For example:

{
    "title": "An error occurred.",
    "detail": "TimeStart must be earlier than TimeEnd."
}

The endpoint handler is not executed when validation fails.

Calling the Endpoint:

return await next(efiContext);

If validation succeeds, the filter calls the next stage in the pipeline, which executes the endpoint handler.

Execution flow:

HTTP Request
      │
      ▼
Endpoint Filter
      │
      ├── Validation fails
      │       │
      │       ▼
      │  Return Problem()
      │
      └── Validation succeeds
              │
              ▼
      Endpoint Handler
              │
              ▼
      Update Database
              │
              ▼
      Return 204 No Content

Benefits of Using an Endpoint Filter for Validation:

• Separation of concerns: Validation logic is kept separate from the endpoint’s business logic.
• Code reuse: The same validation filter can be applied to multiple endpoints.
• Cleaner handlers: Endpoint methods remain focused on processing valid requests.
• Consistent error handling: All validation failures can return a standardized response format.
• Improved maintainability: Validation rules can be updated in one place without modifying individual endpoints.

Implementing IEndpointFilter interface

Besides being defined as delegates, endpoint filters can also be implemented by creating a class that implements the IEndpointFilter interface. This approach encapsulates the filter logic within a reusable class, making it easier to maintain and apply across multiple endpoints. The following code demonstrates the previous validation filter implemented as a class that implements the IEndpointFilter interface:

public class WorkIsValidFilter : IEndpointFilter
{
    private ILogger _logger;

    public WorkIsValidFilter(ILoggerFactory loggerFactory)
    {
        _logger = loggerFactory.CreateLogger<WorkIsValidFilter>();
    }

    public async ValueTask<object?> InvokeAsync(EndpointFilterInvocationContext efiContext,
        EndpointFilterDelegate next)
    {
        var work = efiContext.GetArgument<Work>(1);

        var validationError = Utilities.IsValid(work!);

        if (!string.IsNullOrEmpty(validationError))
        {
            _logger.LogWarning(validationError);
            return Results.Problem(validationError);
        }
        return await next(efiContext);
    }
}

Filters that implement the IEndpointFilter interface can access services registered in the Dependency Injection (DI) container through constructor injection or service resolution, as demonstrated in the previous example. However, while endpoint filters can use dependencies provided by DI, the filter instances themselves are not resolved directly from the DI container.

The “WorkIsValidFilter” is applied to the following endpoints:

app.MapPut("/works/{id}", async (int id, Work work, WorkDb db) =>
{
    var todo = await db.Works.FindAsync(id);

    if (todo is null) return Results.NotFound();

    todo.Name = work.Name;
    todo.TimeStart = work.TimeStart;
    todo.TimeEnd = work.TimeEnd;
    todo.IsComplete = work.IsComplete;

    await db.SaveChangesAsync();

    return Results.NoContent();
}).AddEndpointFilter<WorkIsValidFilter>(); 

Authentication & Authorization in Minimal API

Authentication verifies the identity of a user before allowing access to an API. Once the user’s identity is established, authorization determines whether the authenticated user has permission to access specific API resources.

In ASP.NET Core, authorization is handled by the IAuthorizationService, which is registered when you call the AddAuthorization extension method.

In the following example, the /hello endpoint is protected by an authorization policy. To access this endpoint, the authenticated user must satisfy two requirements:

1. Belong to the “admin” role.
2. Have a scope claim with the value “head”.

Only users who meet both conditions are authorized to access the /hello resource.

The code below creates a new authorization policy named LevelOne that encapsulates two authorization requirements:

1. A role-based requirement via the RequireRole for users with an admin role.
2. A claim-based requirement via the RequireClaim for which the user must provide a head scope claim.

The LevelOne policy is provided as a required policy to the /hello endpoint:

using Microsoft.Identity.Web;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddAuthorizationBuilder()
  .AddPolicy("LevelOne", policy =>
        policy
            .RequireRole("admin")
            .RequireClaim("scope", "head"));

var app = builder.Build();

app.MapGet("/hello", () => "Hello world!")
  .RequireAuthorization("LevelOne");

app.Run();

Using an Endpoint Filter for Custom Authorization

Filters are useful when you need authorization rules that go beyond the built-in policy system. For example, suppose only the owner of a work item may edit it.

public class OwnerFilter : IEndpointFilter
{
    public async ValueTask<object?> InvokeAsync(
        EndpointFilterInvocationContext context,
        EndpointFilterDelegate next)
    {
        var httpContext = context.HttpContext;

        if (!httpContext.User.Identity!.IsAuthenticated)
        {
            return Results.Unauthorized();
        }

        var userId = httpContext.User.FindFirst("sub")?.Value;

        var work = context.GetArgument<Work>(1);

        if (work.OwnerId != userId)
        {
            return Results.Forbid();
        }

        return await next(context);
    }
}

Apply the filter:

app.MapPut("/works/{id}", UpdateWork)
    .AddEndpointFilter<OwnerFilter>()
    .RequireAuthorization();

Execution Flow:

Client Request
      │
      ▼
Authentication Middleware
      │
      ▼
Authorization Middleware
      │
      ▼
Endpoint Filter (Custom Rule)
      │
      ▼
Endpoint Handler
      │
      ▼
Database

Best Practice

Use the built-in authentication and authorization system for securing your Minimal APIs. Endpoint filters should complement this system by implementing application-specific rules, such as verifying resource ownership, checking business constraints, or enforcing custom access requirements. This separation keeps your application secure, maintainable, and aligned with ASP.NET Core best practices.

Endpoint filters are a powerful feature of ASP.NET Core Minimal APIs that provide a clean and reusable way to execute logic before and after an endpoint handler. They help separate cross-cutting concerns, such as validation, logging, authentication, authorization, and exception handling, from the core business logic, resulting in cleaner and more maintainable endpoint implementations.

By encapsulating common functionality in filters, developers can reduce code duplication, improve consistency across endpoints, and simplify application maintenance. Whether implemented as delegates for simple scenarios or as classes implementing the IEndpointFilter interface for more complex and reusable functionality, endpoint filters enhance the flexibility, readability, and scalability of Minimal API applications, making them an essential tool for building robust and maintainable web APIs.

The post Filters in ASP.NET Core Minimal API appeared first on YogiHosting.

string return values

The following endpoints return a Hello world text. The 200 status code is returned with text/plain Content-Type header.

app.MapGet("/hello", () => "Hello World");
app.MapGet("/hello", () => Results.Text("Hello World"));

JSON response

The below 2 endpoints return a json with value Hello World. The 200 status code is returned with application/json Content-Type header.

app.MapGet("/hello", () => new { Message = "Hello World" });
app.MapGet("/hello", () => Results.Json(new { Message = "Hello World" }));

Custom Status Code

The endpoint returns a 405 status code.

app.MapGet("/405", () => Results.StatusCode(405));

Internal Server Error

The endpoint returns a 500 status code.

app.MapGet("/500", () => Results.InternalServerError("Something went wrong!"));

Adding and Modifying Headers

Use the HttpResponse object to add or modify response headers:

app.MapGet("/", (HttpContext context) => {
    // Add a custom header
    context.Response.Headers["X-App-Custom-Header"] = "CustomValue";

    // Modify a header called CacheControl
    context.Response.Headers.CacheControl = $"public,max-age=3600";

    return "Hello World";
});

Redirect

app.MapGet("/old-path", () => Results.Redirect("/new-path"));

File

app.MapGet("/download", () => Results.File("somefile.text"));

Stream Response in Minimal API

Instead of downloading the entire response into a string or byte array, we can return a Stream connected to the response body. Using a stream is beneficial because:

1. it avoids loading the entire file into memory.
2. it’s efficient for large files.
3. data can begin flowing to the client immediately.

For example, if the remote server returns:

[
  {
    "name": "Pikachu",
    "type": "Electric"
  }
]

the stream contains those bytes as they arrive.

Check the below code where stream is the response from a minimal api endpoint.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

var proxyClient = new HttpClient();
app.MapGet("/product", async () => 
{
    var stream = await proxyClient.GetStreamAsync("http://flipkart.com/products/saleproducts.json");
    // Proxy the response as JSON
    return Results.Stream(stream, "application/json");
});

app.Run();

In the above code, the last line returns a stream – return Results.Stream(stream, "application/json");.

Results.Stream() creates an HTTP response whose body is the provided stream.

The second parameter:

"application/json"

sets the response’s Content-Type header.

HTTP/1.1 200 OK
Content-Type: application/json

And this is followed by the JSON from the remote server.

When the browser request:

GET http://localhost:5000/product

The sequence is:

Client
   │
   │ GET /product
   ▼
Your ASP.NET API
   │
   │ GET http://flipkart.com/products/saleproducts.json
   ▼
Flipkart Server
   │
   │ JSON Stream
   ▼
Your API
   │
   │ Streams bytes directly
   ▼
Client

The minimal api does not parse or modify the JSON—it simply forwards it.

Without streaming, we might write:

var json = await proxyClient.GetStringAsync("http://flipkart.com/products/saleproducts.json");
return Results.Content(json, "application/json");

This approach:

1. downloads the entire JSON into memory,
2. creates a large string,
3. then sends it to the client.

With Results.Stream:

var stream = await proxyClient.GetStreamAsync(...);
return Results.Stream(stream, "application/json");

The data is forwarded as it is read from the upstream server, making it more memory-efficient, especially for large responses.

Stream a video from Minimal API

Serving large video files can be done by Results.Stream. The below given code streams a video stored in an Azure Blob Storage container to the client.

using Azure.Storage.Blobs;

var builder = WebApplication.CreateBuilder(args);

// Register BlobServiceClient
builder.Services.AddSingleton(_ =>
    new BlobServiceClient(builder.Configuration.GetConnectionString("AzureBlobStorage")));

var app = builder.Build();

app.MapGet("/video/{fileName}", async (string fileName, BlobServiceClient blobServiceClient) =>
{
    // Get the blob container
    var containerClient = blobServiceClient.GetBlobContainerClient("videos");

    // Get the requested blob
    var blobClient = containerClient.GetBlobClient(fileName);

    // Check whether the blob exists
    if (!await blobClient.ExistsAsync())
    {
        return Results.NotFound("Video not found.");
    }

    // Open the blob as a stream
    var stream = await blobClient.OpenReadAsync();

    // Stream the video to the client
    return Results.Stream(
        stream,
        contentType: "video/mp4",
        fileDownloadName: fileName);
});

app.Run();

• A BlobServiceClient is registered with dependency injection.
• The endpoint accepts the video file name as a route parameter.
• The API connects to the videos container in Azure Blob Storage.
• It checks whether the requested blob exists.
• If the blob exists, OpenReadAsync() opens a stream to the blob.
• Results.Stream() streams the video directly to the client without loading the entire file into memory.
• The response uses the video/mp4 content type so browsers and media players can recognize and play the video.

Returning ProblemDetails response from Minimal API

ProblemDetails is a standardized way for a Web API to return error information to clients. It is based on the IETF standard RFC 7807 (now updated by RFC 9457) and is built into ASP.NET Core.

Instead of returning inconsistent error responses like:

{
  "error": "Something went wrong"
}

You return a structured response like:

{
  "type": "https://example.com/errors/not-found",
  "title": "Resource not found",
  "status": 404,
  "detail": "The product with ID 10 does not exist.",
  "instance": "/api/products/10"
}

Properties of ProblemDetails:

IProblemDetailsService is the service responsible for creating and writing ProblemDetails responses in ASP.NET Core. In the Program.cs class, register the Problem Details service with ASP.NET Core’s dependency injection container. It enables your application to produce standardized RFC 9457/RFC 7807 error responses (ProblemDetails) for exceptions and HTTP error status codes.

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddProblemDetails();

var app = builder.Build();

app.UseExceptionHandler();
app.UseStatusCodePages();

app.MapGet("/employee/{id:int}", (int id) => id <= 0 ? Results.BadRequest() : Results.Ok(new Employee(id)));

app.Run();

What does AddProblemDetails() do? – It tells ASP.NET Core: “When an error occurs, generate a standardized ProblemDetails response instead of a plain text or HTML error page.”

Without AddProblemDetails() – Suppose an exception occurs by the below code.

app.MapGet("/", () =>
{
    throw new Exception("Database connection failed");
});

The response will be in plain text:

An error occurred while processing your request.

(or an HTML error page (depending on the environment and middleware).)

With AddProblemDetails() – The same exception can produce a JSON response like:

{
  "type": "https://tools.ietf.org/html/rfc9110#section-15.6.1",
  "title": "An error occurred while processing your request.",
  "status": 500
}

This format is consistent and easier for API clients to consume.

[HttpGet("{id}")]
public IActionResult GetProduct(int id)
{
    var product = repository.Get(id);

    if (product == null)
    {
        return Problem(
            title: "Product not found",
            detail: $"No product exists with ID {id}.",
            statusCode: StatusCodes.Status404NotFound);
    }

    return Ok(product);
}

The response:

{
  "type": "https://tools.ietf.org/html/rfc9110#section-15.5.5",
  "title": "Product not found",
  "status": 404,
  "detail": "No product exists with ID 5."
}

You can create one manually:

var problem = new ProblemDetails
{
    Title = "Insufficient Balance",
    Detail = "Your account balance is too low.",
    Status = StatusCodes.Status400BadRequest,
    Type = "https://example.com/errors/insufficient-balance",
    Instance = HttpContext.Request.Path
};

problem.Extensions["errorCode"] = "BAL001";
problem.Extensions["traceId"] = HttpContext.TraceIdentifier;

return BadRequest(problem);

The response:

{
  "type": "https://example.com/errors/insufficient-balance",
  "title": "Insufficient Balance",
  "status": 400,
  "detail": "Your account balance is too low.",
  "instance": "/api/payments",
  "errorCode": "BAL001",
  "traceId": "00-abc123..."
}

We can also return ProblemDetails response with a custom extension. ProblemDetails has an Extensions property, which is a dictionary for adding custom information. Here we’re creating a collection of key-value pairs.

app.MapGet("/customerror", () =>
{
    var ext = new List<KeyValuePair<string, object?>> { new("test", "value") };
    return TypedResults.Problem("This is an error with extensions", extensions: ext);
});

This endpoint defines a GET route at /customerror that returns an RFC 7807 error response.

How it works:

• app.MapGet(“/customerror”, …) registers a GET endpoint that responds to requests made to /problem.
• A collection of extension properties is created containing a single key-value pair:
• Key: “test”
• Value: “value”
• TypedResults.Problem() creates a Problem Details response, which is the standard format for communicating HTTP API errors. The first argument (“This is an error with extensions”) populates the detail property of the response.
• The extensions parameter adds custom fields to the Problem Details payload. These properties appear alongside the standard fields (type, title, status, detail, and instance) and can be used to include additional error information.

A response from this endpoint resembles the following:

{ 
    "type": "about:blank", 
    "title": "An error occurred.", 
    "status": 500, 
    "detail": "This is an error with extensions", 
    "test": "value" 
}

Using the extensions property is useful when clients need additional context, such as correlation IDs, error codes, validation metadata, or other application-specific information, while still conforming to the Problem Details specification.

Customize validation error responses using IProblemDetailsService

IProblemDetailsService is the service responsible for creating and writing ProblemDetails responses in ASP.NET Core. When we call:

builder.Services.AddProblemDetails();

ASP.NET Core registers an implementation of IProblemDetailsService in the dependency injection (DI) container.

Why does it exist? Instead of every middleware or endpoint manually creating a ProblemDetails object, they can delegate the work to IProblemDetailsService. This keeps error handling centralized and consistent.

Think of it like this:

Exception occurs
        │
        ▼
UseExceptionHandler middleware
        │
        ▼
IProblemDetailsService
        │
        ▼
Creates ProblemDetails
        │
        ▼
Writes JSON response

Suppose you have custom middleware. Instead of doing this:

app.Use(async (context, next) =>
{
    try
    {
        await next();
    }
    catch
    {
        context.Response.StatusCode = 500;

        await context.Response.WriteAsJsonAsync(new ProblemDetails
        {
            Title = "Unexpected Error",
            Status = 500
        });
    }
});

You can use IProblemDetailsService.

app.Use(async (context, next) =>
{
    var problemService =
        context.RequestServices.GetRequiredService<IProblemDetailsService>();

    try
    {
        await next();
    }
    catch
    {
        await problemService.TryWriteAsync(new ProblemDetailsContext
        {
            HttpContext = context,
            ProblemDetails = new ProblemDetails
            {
                Title = "Unexpected Error",
                Status = 500
            }
        });
    }
});

Now the response is generated using the same service used throughout the application.

ProblemDetailsContext : TryWriteAsync() accepts a ProblemDetailsContext.

new ProblemDetailsContext
{
    HttpContext = context,
    ProblemDetails = new ProblemDetails
    {
        Title = "Invalid Request",
        Detail = "The supplied data is incorrect.",
        Status = 400
    }
}

The context contains:

• HttpContext
• ProblemDetails
• Exception (optional)
• Additional metadata

Returning File response from Minimal API

In Minimal APIs, the most commonly used approach for returning a file is TypedResults.File. It accepts either a byte[] or a Stream and returns a FileContentHttpResult or FileStreamHttpResult, respectively.

The endpoint defines a Minimal API route that generates a PDF in memory and returns it as a downloadable file.

app.MapGet("/pdfdownload", () =>
{
    // TypedResults.File with a byte[] returns a FileContentHttpResult
    byte[] pdf = GenerateReport();
    return TypedResults.File(pdf, "application/pdf", "work.pdf");
});

Here’s what each part does:

• app.MapGet(“/pdfdownload”, …) registers a GET endpoint at /pdfdownload. When a client sends a GET request to this URL, the lambda expression is executed.
• byte[] pdf = GenerateReport() calls a method that generates the PDF content and returns it as a byte[]. The entire PDF is stored in memory before it is sent to the client.
• TypedResults.File(…) creates a file response from the byte array. Since the input is a byte[], it returns a FileContentHttpResult.

The TypedResults.File method takes three arguments:

1. pdf – The file content as a byte[].
2. “application/pdf” – The MIME type (Content-Type) of the response, which tells the client that the file is a PDF document.
3. “work.pdf” – The suggested filename for the downloaded file. ASP.NET Core includes this value in the Content-Disposition response header so that browsers typically download the file using this name.

When a client requests /pdfdownload, the server generates the PDF, sets the appropriate HTTP headers, and sends the file to the client. Most web browsers will prompt the user to download the file (or open it with a PDF viewer), using work.pdf as the default filename.

This endpoint creates a stream in memory and returns it as a file to the client.

app.MapGet("/filedownload", () =>
{
    // TypedResults.File with a Stream returns a FileStreamHttpResult
    Stream stream = new MemoryStream("Hello, World!"u8.ToArray());
    return TypedResults.File(stream, "application/octet-stream");
});

Here’s how it works:

• app.MapGet(“/download”, …) registers a GET endpoint at /download. The lambda expression runs whenever a client sends a GET request to this URL.
• Stream stream = new MemoryStream(“Hello, World!”u8.ToArray()) creates a MemoryStream containing the text “Hello, World!”.
• “Hello, World!” is a UTF-8 string literal that produces a ReadOnlySpan containing the UTF-8 encoded bytes of the string. .ToArray() converts the span into a byte[].
• new MemoryStream(…) wraps the byte array in a stream so it can be read and sent to the client.
• TypedResults.File(stream, “application/octet-stream”) creates a file response from the stream. Because the input is a Stream, it returns a FileStreamHttpResult.

The TypedResults.File method takes two arguments:

1. stream – The stream containing the file data.
2. “application/octet-stream” – The MIME type of the response. This generic binary content type tells the client that the response contains arbitrary binary data.

Unlike the previous example, this overload does not specify a download filename. As a result, ASP.NET Core doesn’t include a Content-Disposition header with a filename, so the browser determines how to handle the response. Some browsers may display the content, while others may download it with a generated filename.

The Content-Disposition header is an HTTP response header that tells the client (such as a web browser) how the returned content should be handled. It is commonly used to indicate whether a file should be displayed inline or downloaded, and to provide a default filename.

Syntax:

Content-Disposition: disposition-type; filename="filename.ext"

The two most common disposition types are:

1. inline – Display the content in the browser if possible.
2. attachment – Prompt the user to download the file.

Example 1: Download a file

HTTP/1.1 200 OK
Content-Type: application/pdf
Content-Disposition: attachment; filename="work.pdf"

Example 2: Display a file in the browser

HTTP/1.1 200 OK
Content-Type: application/pdf
Content-Disposition: inline; filename="work.pdf"

When we write:

return TypedResults.File(pdf, "application/pdf", "work.pdf");

ASP.NET Core automatically sets a Content-Disposition header similar to:

Content-Disposition: attachment; filename="work.pdf"

This tells the browser to download the file and use work.pdf as the default filename.

If you omit the filename:

return TypedResults.File(stream, "application/octet-stream");

ASP.NET Core doesn’t set a Content-Disposition header with a filename. The browser then decides how to handle the response based on the content type and its own behavior.

OpenAPI support for File Response

File result types do not automatically add response metadata to the generated OpenAPI document. To ensure the response is accurately described in the OpenAPI specification, you must explicitly provide the required response metadata.

For this we use Produces() method to provide the OpenAPI metadata for the response. This metadata defines the response’s status code, content type, and schema in the generated OpenAPI document. For example we specify content type as “application/pdf” for a pdf file.

We now have added the Produces() method to provide the OpenAPI metadata for the pdf file.

app.MapGet("/pdfdownload", () =>
{
    // TypedResults.File with a byte[] returns a FileContentHttpResult
    byte[] pdf = GenerateReport();
    return TypedResults.File(pdf, "application/pdf", "work.pdf");
})
.Produces(StatusCodes.Status200OK, contentType: "application/pdf");

The .Produces method adds response metadata to the generated OpenAPI document. In this example:

• StatusCodes.Status200OK specifies that the endpoint returns an HTTP 200 OK response.
• contentType: “application/pdf” indicates that the response body is a PDF document.

This metadata allows OpenAPI tools such as Swagger UI to correctly document the endpoint as returning a PDF file.

The generated response section in the OpenAPI document is similar to:

responses:
  "200":
    description: OK
    content:
      application/pdf: {}

Without the .Produces call, the endpoint still returns the PDF correctly at runtime, but the generated OpenAPI document lacks the response metadata needed to accurately describe the file response.

In the same way we have used Produces method for the above second example.

app.MapGet("/filedownload", () =>
{
    // TypedResults.File with a Stream returns a FileStreamHttpResult
    Stream stream = new MemoryStream("Hello, World!"u8.ToArray());
    return TypedResults.File(stream, "application/octet-stream");
})
.Produces<Stream>(contentType: MediaTypeNames.Application.Octet);

For text content, such as CSV or plain text, use contentType: “text/plain”:

app.MapGet("/download/message", () =>
{
    string content = "Hello, World!";

    byte[] bytes = Encoding.UTF8.GetBytes(content);

    // TypedResults.File with byte[] returns FileContentHttpResult
    return TypedResults.File(
        bytes,
        "text/plain",
        "message.txt");
})
.Produces(StatusCodes.Status200OK, contentType: "text/plain");

For CSV or plain text where the response body is a text value, use string as the TResponse for this case and contentType: “text/csv”:

app.MapGet("/users/csv", () =>
{
    string csv = """
                 Id,Name,Email
                 1,John,john@example.com
                 2,Jane,jane@example.com
                 """;

    return csv;
})
.Produces<string>(StatusCodes.Status200OK, contentType: "text/csv");

File Responses for Conditional Requests and Cache Validation

File responses can support HTTP conditional requests to improve caching efficiency. By including cache validation headers such as “ETag” and “Last-Modified”, the server allows clients to determine whether a cached copy of a file is still valid.

When a client makes a request, it can include conditional headers such as If-None-Match (using an ETag) or If-Modified-Since (using a Last-Modified timestamp). The server can use these values to check whether the file has changed.

If the file has not changed, the server returns 304 Not Modified, allowing the client to use its cached copy without downloading the file again. If the file has changed, the server returns 200 OK with the updated file content and updated cache metadata.

In ASP.NET Core Minimal APIs, file results can include ETag and Last-Modified values to provide cache validation information. However, the application must implement the conditional request logic to compare incoming request headers and decide whether to return 304 Not Modified.

Check the below example:

app.MapGet("/shoesale", (
    [FromHeader(Name = "If-None-Match")] string? ifNoneMatch,
    [FromHeader(Name = "If-Modified-Since")] string? ifModifiedSince) =>
{
    byte[] data = File.ReadAllBytes("Products/SaleShoes.json");
    var lastModified = File.GetLastWriteTimeUtc("Products/SaleShoes.json");
    var etag = new EntityTagHeaderValue($"\"{Convert.ToHexString(SHA256.HashData(data))}\"");

    return TypedResults.File(
        data,
        contentType: MediaTypeNames.Application.Json,
        lastModified: lastModified,
        entityTag: etag);
})
.Produces<object>(StatusCodes.Status200OK)
.Produces(StatusCodes.Status304NotModified);

To enable cache validation, a file response from minimal api can include metadata such as:

• ETag: A unique identifier representing a specific version of the resource.
• Last-Modified: The date and time when the resource was last changed.

Clients can send conditional request headers based on this metadata:

• If-None-Match: Contains the previously received ETag value.
• If-Modified-Since: Contains the previously received Last-Modified timestamp.

The server compares the values provided by the client with the current resource metadata:

• If the resource has not changed, the server returns 304 Not Modified without sending the file content. The client uses its cached copy.
• If the resource has changed, the server returns 200 OK with the updated file content and cache validation metadata.

The parameters read request headers sent by the client.

[FromHeader(Name = "If-None-Match")] string? ifNoneMatch,
[FromHeader(Name = "If-Modified-Since")] string? ifModifiedSince)

Reading the JSON file:

byte[] data = File.ReadAllBytes("Products/SaleShoes.json");

Getting the last modified time:

var lastModified = File.GetLastWriteTimeUtc("Products/SaleShoes.json");

Creating an ETag:

var etag = new EntityTagHeaderValue(
    $"\"{Convert.ToHexString(SHA256.HashData(data))}\"");

If SaleShoes.json changes, the hash changes, so the ETag changes.

Returning the file:

return TypedResults.File(
    data,
    contentType: MediaTypeNames.Application.Json,
    lastModified: lastModified,
    entityTag: etag);

The response contains the json file along with Last-Modified and ETag values:

HTTP/1.1 200 OK
Content-Type: application/json
Last-Modified: Sat, 11 Jul 2026 10:30:00 GMT
ETag: "A1B2C3D4E5"

The client can store these values for future requests.

OpenAPI metadata:

.Produces<object>(StatusCodes.Status200OK)
.Produces(StatusCodes.Status304NotModified);

The client uses If-None-Match to ask the server:

"I already have the version of this resource identified by this ETag. Send it again only if it has changed."

If the resource hasn’t changed, the server responds with 304 Not Modified instead of sending the resource again.

Step 1: Client requests a resource:

GET /shoesale HTTP/1.1

The server responds with the JSON file and an ETag:

HTTP/1.1 200 OK
Content-Type: application/json
ETag: "A1B2C3D4"

[
  {
    "name": "Running Shoe",
    "price": 50
  }
]

The client stores: The response body and ETag value. Below is an ETag value:

"A1B2C3D4"

Step 2: Client requests the resource again:

GET /shoesale HTTP/1.1
If-None-Match: "A1B2C3D4"

The client is saying:

"I already have version A1B2C3D4. Send me the file only if the current version is different."

Step 3: Server compares the ETag:

The server calculates the current ETag for the file.

Case 1: The file has not changed

Current ETag:

"A1B2C3D4"

Client sent:

"A1B2C3D4"

They match, so the server responds:

HTTP/1.1 304 Not Modified

No response body is sent. The client continues using its cached copy.

Case 2: The file has changed:

Suppose the file was updated.

The server calculates a new ETag:

"F9E8D7C6"

Now Client sends:

"A1B2C3D4"

Server calculates:

"F9E8D7C6"

The ETags do not match, so the server returns:

HTTP/1.1 200 OK
Content-Type: application/json
ETag: "F9E8D7C6"

[
  {
    "name": "Running Shoe",
    "price": 45
  }
]

The client updates its cache with the new file and ETag.

The client is essentially saying:

"Send me this resource only if it has been modified after this date."

If the resource has not changed, the server responds with 304 Not Modified and does not send the resource body again.

1. First request

A client requests a file:

GET /shoesale HTTP/1.1

The server returns the file and includes a Last-Modified header:

HTTP/1.1 200 OK
Content-Type: application/json
Last-Modified: Sat, 11 Jul 2026 10:30:00 GMT

[
  {
    "name": "Running Shoe",
    "price": 50
  }
]

The Last-Modified header tells the client:

"This file was last changed at this time."

The client stores:

1. The response body
2. The Last-Modified date

2. Client makes a later request

When the client needs the file again, it sends:

GET /shoesale HTTP/1.1
If-Modified-Since: Sat, 11 Jul 2026 10:30:00 GMT

The client is saying:

"I already have a copy from 10:30. Has it changed since then?"

3. Server checks the modification date

var lastModified = File.GetLastWriteTimeUtc("Products/SaleShoes.json");

Case 1: File has not changed

Client sends:

If-Modified-Since: 10:30

Server file:

Last-Modified: 10:30

The file is unchanged, so the server responds:

HTTP/1.1 304 Not Modified

No file content is sent. The client uses its cached copy.

Case 2: File has changed

Client sends:

If-Modified-Since: 10:30

Server file:

Last-Modified: 11:15

The file is newer, so the server responds:

HTTP/1.1 200 OK
Content-Type: application/json
Last-Modified: Sat, 11 Jul 2026 11:15:00 GMT

[
  {
    "name": "Running Shoe",
    "price": 45
  }
]

The client receives the updated file.

File Response for range requests

In ASP.NET Core Minimal APIs, “File result support for range requests” refers to the ability of file-returning endpoints to handle the HTTP Range header automatically. This allows clients to download or stream only a portion of a file instead of the entire file.

This is particularly useful for:

• 🎥 Video and audio streaming
• 📥 Resuming interrupted downloads
• 📄 Reading parts of large files
• 🚀 Reducing bandwidth usage

Without range request support

Suppose you have a Minimal API endpoint:

app.MapGet("/download", () =>
{
    return Results.File(
        "Files/report.pdf",
        "application/pdf");
});

If a client requests:

GET /download HTTP/1.1
Range: bytes=0-999

the server ignores the Range header and returns the entire file is sent.

HTTP/1.1 200 OK
Content-Length: 5000000

Here the entire 5 MB file is sent.

With range request support

ASP.NET Core lets you enable range processing by setting enableRangeProcessing to true.

app.MapGet("/download", () =>
{
    return Results.File(
        path: "Files/report.pdf",
        contentType: "application/pdf",
        enableRangeProcessing: true);
});

Now, if the client requests:

GET /download HTTP/1.1
Range: bytes=0-999

ASP.NET Core automatically:

• Parses the Range header.
• Validates the requested byte range.
• Reads only that portion of the file.
• Returns the correct HTTP response.

The response becomes:

HTTP/1.1 206 Partial Content
Accept-Ranges: bytes
Content-Range: bytes 0-999/5000000
Content-Length: 1000

Only the first 1000 bytes are sent.

This endpoint exposes a video file through an ASP.NET Core Minimal API and enables HTTP Range Requests, allowing clients (such as browsers or video players) to request only portions of the video.

app.MapGet("/catvideo/{id}", (string id, [FromHeader(Name = "Range")] string? range) =>
{
    var bytes = GetVideo(id);

    return TypedResults.File(
        bytes,
        contentType: "video/mp4",
        fileDownloadName: "cat.mp4",
        enableRangeProcessing: true);
})
.Produces<Stream>(StatusCodes.Status200OK, "video/mp4")
.Produces<Stream>(StatusCodes.Status206PartialContent, "video/mp4")
.Produces(StatusCodes.Status416RangeNotSatisfiable);

Let us understand the code.

1. Mapping the endpoint

app.MapGet("/catvideo/{id}", ...)

Creates a GET endpoint.

Example request:

GET /catvideo/123

Here:

id = "123"

2. Reading the Range header

[FromHeader(Name = "Range")] string? range

This tells ASP.NET Core:

Read the HTTP Range header and bind it to the range parameter.

For example, if the client sends:

GET /catvideo/123 HTTP/1.1
Range: bytes=1000-5000

<p>then</p>

range == "bytes=1000-5000"

If the client doesn’t send a Range header:

GET /catvideo/123

then

range == null

Why isn’t range used? Notice that the code never references the range variable. That’s because:

TypedResults.File(..., enableRangeProcessing: true)

already reads and processes the Range header internally from the HTTP request. The range parameter is therefore optional and is often included only for: logging, debugging, custom validation, or documenting that the endpoint supports range requests.

You could remove it entirely, and range processing would still work.

app.MapGet("/catvideo/{id}",
    (string id,
     [FromHeader(Name = "Range")] string? range,
     ILogger<Program> logger) =>
{
    logger.LogInformation(
        "Video requested. Id: {VideoId}, Range: {Range}",
        id,
        range ?? "<entire file>");

    var bytes = GetVideo(id);

    logger.LogInformation(
        "Serving video '{VideoId}' ({Size} bytes) with range processing {Enabled}.",
        id,
        bytes.Length,
        true);

    return TypedResults.File(
        bytes,
        contentType: "video/mp4",
        fileDownloadName: "cat.mp4",
        enableRangeProcessing: true);
})
.Produces<Stream>(StatusCodes.Status200OK, "video/mp4")
.Produces<Stream>(StatusCodes.Status206PartialContent, "video/mp4")
.Produces(StatusCodes.Status416RangeNotSatisfiable);

3. Loading the video

var bytes = GetVideo(id);

Suppose

byte[] bytes = File.ReadAllBytes("cat.mp4");

Now bytes contains the entire video in memory. For very large videos, using a Stream is generally preferable to avoid loading the whole file into memory.

4. Returning the file

return TypedResults.File(
    bytes,
    contentType: "video/mp4",
    fileDownloadName: "cat.mp4",
    enableRangeProcessing: true);

Each parameter has a purpose:

bytes

The content to send to the client.

contentType

"video/mp4"

Sets the HTTP response header:

Content-Type: video/mp4

So browsers know it’s an MP4 video.

fileDownloadName

"cat.mp4"

This influences the Content-Disposition header. If the browser downloads the file, it suggests the filename cat.mp4.

enableRangeProcessing

true

This is the key setting. It tells ASP.NET Core:

• Look for the Range header.
• Validate the requested byte range.
• Send only the requested bytes if the range is valid.
• Return 206 Partial Content.
• Return 416 Range Not Satisfiable for invalid ranges.
• Include Accept-Ranges: bytes in the response.

Without this flag, the framework would ignore the Range header and return the entire file with 200 OK.

5. Example request without a Range header

Client:

GET /catvideo/123

Response:

200 OK
Content-Type: video/mp4
Content-Length: 52428800

The full 50 MB video is returned.

6. Example request with a Range header

Client:

GET /catvideo/123
Range: bytes=0-999999

The framework sends only the first 1,000,000 bytes.

Response:

206 Partial Content
Accept-Ranges: bytes
Content-Range: bytes 0-999999/52428800
Content-Length: 1000000

This is how browsers can start playing a video before downloading the entire file.

7. Invalid Range

Suppose the file size is:

50 MB

but the client requests:

Range: bytes=100000000-200000000

Those byte positions don’t exist.

ASP.NET Core responds:

416 Range Not Satisfiable

along with a Content-Range header indicating the valid total size.

8. The .Produces() calls

These methods don’t change the runtime behavior of the endpoint. Instead, they describe the possible responses for API metadata and OpenAPI/Swagger generation.

Successful full response

.Produces<Stream>(
    StatusCodes.Status200OK,
    "video/mp4")

Documents that the endpoint can return:

200 OK
Content-Type: video/mp4

when the entire file is sent.

In case of Partial response:

.Produces<Stream>(
    StatusCodes.Status206PartialContent,
    "video/mp4")

Documents that the endpoint may return:

206 Partial Content

when it fulfills a valid range request.

In case of Invalid range:

.Produces(
    StatusCodes.Status416RangeNotSatisfiable);

Documents that the endpoint may return:

416 Range Not Satisfiable

for an invalid Range header.

How it all works together

• A client requests /catvideo/123.
• If there is no Range header, ASP.NET Core returns the full video with 200 OK.
• If there is a valid Range header, ASP.NET Core returns only the requested bytes with 206 Partial Content.
• If the range is invalid, it returns 416 Range Not Satisfiable.
• The .Produces() methods advertise these possible responses in the API’s metadata.

This built-in support is what enables smooth seeking in video players and resumable downloads without requiring you to implement byte-range parsing or response handling yourself.

In this tutorial we covered everything related to Responses in Minimal API. Mastering it is an important step toward building high-quality ASP.NET Core applications. Whether you are developing a small project, a RESTful web service, or a large-scale enterprise application, applying the concepts and best practices discussed in this guide will help you create APIs that are performant, scalable, maintainable, and easy for clients to consume. This knowledge forms a strong foundation for developing robust, production-ready web applications using ASP.NET Core Minimal APIs.

The post Complete Guide to Minimal API Response appeared first on YogiHosting.

Before we dive into parameter binding we have to understand what are routes and handlers.

Routes, Handlers and Parameters

In ASP.NET Core Minimal APIs, a route defines how an incoming HTTP request—identified by its URL path and HTTP method is mapped to a specific handler or delegate that contains the application’s business logic. Minimal APIs register endpoints directly on the WebApplication instance resulting in a lightweight, streamlined approach with minimal configuration and overhead.

Route handlers are methods that execute when the route matches. Route handlers can be a lambda expression, a local function, an instance method, or a static method.

// Example of lambda expression
app.MapGet("/example1", () => "This is lambda expression");


// Example of local function

string LocalFunction() => "This is local function";

app.MapGet("/example2", LocalFunction);


// Example of Instance method

app.MapGet("/example3", handler.Hello);

class HelloHandler
{
    public string Hello()
    {
        return "Hello Instance method";
    }
}


// Example of static method

app.MapGet("/", HelloHandler.Hello);

class HelloHandler
{
    public static string Hello()
    {
        return "Hello static method";
    }
}

A Route parameter is a variable segment of a URL that allows values to be passed from the request URL to an endpoint, controller action, or Minimal API handler.

In the below example the route – “/products/books” has a single parameter called name. This route will return the message “The product is books”. In the same way when the route “/products/shoes” is called then it returns the message “The product is shoes”.

app.MapGet("/products/{name}", (string name) => $"The product is {name}");

In the below examples we have 2 route parameters countryName and cityName.

app.MapGet("/country/{countryName}/city/{cityName}", (string countryName, string cityName) => $"The country is {countryName} and city is {cityName}");

The route /country/India/city/Lucknow will return “The country is India and City is Lucknow”.

Route Constraints

Route constraints are used to restrict which URLs match a Minimal API route by validating route parameter values. They help ensure that only requests with the correct format reach a specific action or endpoint.

In the below code we have added an int constraint to the “id” parameter so that only int values reaches it.

app.MapGet("/example/{id:int}", (int id) =>  $"The value of id is {id}");

The matching format for the above route – /example/1, /example/10, /example/99. The route /example/hello will not match since id value in the route is string (i.e. hello).

In the below case we have not applied any constraint.

app.MapGet("/example/{id}", (string id) =>  $"The value of id is {id}");

The matching format for the above route – /example/1, /example/hello, /example/hello99.

We can also use regex route constraint to match a route parameter against a regular expression. For example in the below code we restrict the following for the slug parameter.

1. Alphabets from a to z including capital letters.
2. Numbers from 0 to 9.
3. Characters _ and -.

app.MapGet("/posts/{slug:regex(^[a-z0-9_-]+$)}", (string slug) => $"Post {slug}");

The matching format in this case are:

• posts/aa33
• /posts/AA33
• /posts/aa-33
• /posts/aa_33

The non-matching formats include.

• /posts/aa.33
• /posts/aa/33

The * character is used as a catch-all parameter. It matches the remainder of the URL path, including multiple path segments. The below example uses * to match all the remainder for the URL path after “match”.

app.MapGet("/match/{*slug}", (string slug) => $"Routing to {slug}");

Examples of formats matched in this case are.

• /match/aa
• /match/aa/aa/dd

Parameter Binding in Minimal API

Parameter binding is the process of mapping incoming request data to the strongly typed parameters defined by route handlers. A binding source specifies where the parameter values are obtained from. Binding sources can be explicitly defined or automatically inferred based on the HTTP method and the parameter type.

Supported binding sources:

• Route values
• Query string
• Header
• Body (as JSON)
• Form values
• Services through dependency injection
• Custom

Default parameter binding rules

In ASP.NET Core Minimal APIs, parameter binding follows a set of default rules to determine where each parameter value should come from. In most cases, you don’t need to specify attributes like [FromQuery] or [FromRoute].

Parameters are bound in the following order:

See the below endpoint.

app.MapGet("/{id}", (int id,
                     int page,
                     [FromHeader(Name = "X-MYCUSTOM-HEADER")] string customHeader,
                     Service service) => { });

In the above example of a GET Endpoint, the Parameters and their respective Binding Sources are given below. Here automatic parameter bindings are done by .NET as given in the below table.

By default, the GET, HEAD, OPTIONS, and DELETE HTTP methods do not bind parameters from the request body. To bind JSON data from the request body for these methods, explicitly use the [FromBody] attribute or read the body directly from the HttpRequest.

The HTTP POST method uses a default binding source of body (as JSON). In the below example the Employee object will be bind from the body.

app.MapPost("/", (Employee emp) => { });

See the below endpoint.

app.MapGet("/{id}", ([FromRoute] int id,
                     [FromQuery(Name = "p")] int page,
                     [FromHeader(Name = "X-MYCUSTOM-HEADER")] string customHeader,
                     [FromServices] Service service) => { });

The above example does explicit parameter binding by the use of FromRoute, FromQuery, FromHeader, and FromServices attributes.

The [FromForm] attribute binds form values explicitly as shown below. Note that if we don’t apply [FromForm] attribute then by default binding source of body (as JSON) is applied by .NET.

app.MapPost("/", ([FromForm] Employee emp) => { });

With the HttpRequest object we can read request data directly from the HTTP request. In ASP.NET Core, HttpRequest is a class that represents the incoming HTTP request sent by the client to your application. It provides access to information such as the request method, URL, headers, query string, form data, cookies, and request body.

See the below example.

app.MapGet("/{id}", (HttpRequest request) =>
{
    var id = request.RouteValues["id"];
    var page = request.Query["page"];
    var customHeader = request.Headers["X-MYCUSTOM-HEADER"];

    // ...
});

app.MapPost("/", async (HttpRequest request) =>
{
    var emp = await request.ReadFromJsonAsync<Employee>();

    // ...
});

Parameter Binding with [AsParameters] attribute

The AsParameters is an attribute that groups multiple parameters into a single object while still binding each property from its appropriate source. This helps keep route handler signatures clean and organized.

For example, there is an endpoint containing multiple parameters.

app.MapGet("/products/{id}",
    (int id, string? search, ILogger<Program> logger) =>
{
    // ...
});

We can change this endpoint by using AsParameters attribute which will be binding a custom type called “ProductRequest” as shown below.

app.MapGet("/products/{id}", ([AsParameters] ProductRequest request) =>
{
    // ...
});

Finally we can define a custom class called ProductRequest.cs containing all the parameters.

public class ProductRequest
{
    public int Id { get; set; }

    public string? Search { get; set; }

    public ILogger<Program> Logger { get; set; } = default!;
}

Each property of the class is bound independently using the normal Minimal API binding rules:

• Route parameters → Route values
• Simple types → Query string (by default)
• Services → Dependency injection

We can override the default binding source by using attributes such as [FromRoute], [FromQuery], [FromHeader], [FromServices], and [FromForm]. See the below updated code of the class.

public class SearchRequest
{
    [FromRoute]
    public int Id { get; set; }

    [FromQuery]
    public string? Search { get; set; }

    [FromHeader(Name = "X-Request-ID")]
    public string? RequestId { get; set; }

    [FromServices]
    public ILogger<Program> Logger { get; set; } = default!;
}

Optional Parameters

Parameters declared in route handlers are considered required. A route handler is invoked only when the incoming request includes all required parameters. If any required parameter is missing, the request fails with an error instead of executing the handler.

We have an endpoint:

app.MapGet("/products", (int pageNumber) => $"Requested page {pageNumber}");

If we invoke the uri – /products then we get the error saying –

BadHttpRequestException: Required parameter "int pageNumber" wasn't provided from query string.

The solution to this is to make pageNumber optional, define the type as optional or provide a default value:

app.MapGet("/products", (int? pageNumber) => $"Requested page {pageNumber}");

app.MapGet("/products", (int pageNumber = 1) => $"Requested page {pageNumber}");

Parameter binding with Dependency Injection

In Minimal APIs, parameters whose types are registered as services are automatically resolved through dependency injection. As a result, you don’t need to explicitly annotate them with the [FromServices] attribute. In the following example, both route handlers receive the service from the DI container and return the current time, even though only one uses [FromServices].

// Register the service 
builder.Services.AddSingleton<TimeService>();

// Minimal API Endpoint
app.MapGet("/time", (TimeService timeService) => { return $"Current time: {timeService.GetCurrentTime()}"; });

// [FromServices] is optional
app.MapGet("/time", ([FromServices] TimeService timeService) => { return $"Current time: {timeService.GetCurrentTime()}"; });

// TimeService class

public class TimeService { public string GetCurrentTime() => DateTime.Now.ToString("T"); }

Binding .NET Special Types

Special Types are bound automatically by .NET without explicit attributes.

* HttpContext : The context holds all the information of the current HTTP request or response.

app.MapGet("/", (HttpContext context) => context.Response.WriteAsync("Hello Minimal API"));

* HttpRequest and HttpResponse : HTTP request and HTTP response.

app.MapGet("/", (HttpRequest request, HttpResponse response) =>
    response.WriteAsync($"Hello Minimal API {request.Query["name"]}"));

* CancellationToken : cancellation token associated with the current HTTP request.

app.MapGet("/", async (CancellationToken cancellationToken) => 
    await LongRunningRequestAsync(cancellationToken));

* ClaimsPrincipal : The user associated with the request, bound from HttpContext.User.

app.MapGet("/", (ClaimsPrincipal user) => user.Identity.Name);

File uploads using IFormFile and IFormFileCollection

To upload files in a Minimal API, the request must use the multipart/form-data content type. Parameters of type IFormFile and supported named file collections such as IReadOnlyList are bound to files in the form data, and the parameter name in the route handler must match the corresponding form field name in the request. Use IFormFile and IReadOnlyList when you need only the files whose form field name matches the parameter name.

When the parameter type is IFormFileCollection, all uploaded files in the multipart/form-data request are bound to the collection, regardless of their form field names.

// Here we are using IFormFile so the parameter name in the route handler (file) must match the corresponding form field name in the request

app.MapPost("/upload", async (IFormFile file) =>
{
    // The Path.GetTempFileName() creates a zero-byte temporary file in the operating system's default temporary directory which is C:\Users\<username>\AppData\Local\Temp\
    var tempFile = Path.GetTempFileName();
    using var stream = File.OpenWrite(tempFile);
    await file.CopyToAsync(stream);
});

// Here we are using IFormFileCollection so all uploaded files in the multipart/form-data request are bound to the collection, regardless of their form field names

app.MapPost("/upload_many", async (IFormFileCollection myFiles) =>
{
    foreach (var file in myFiles)
    {
        var tempFile = Path.GetTempFileName();
        using var stream = File.OpenWrite(tempFile);
        await file.CopyToAsync(stream);
    }
});

IAntiforgery to prevent Cross-Site Request Forgery (XSRF/CSRF) attacks

IAntiforgery is used to generate and validate anti-forgery (CSRF) tokens. It helps protect web applications from Cross-Site Request Forgery (CSRF) attacks, where a malicious site tricks a user’s browser into submitting unwanted requests.

To implement anti-forgery token generate a form with an anti-forgery token and an /upload endpoint. In the /upload endpoint validates the anti-forgery token in the incoming request. If validation fails, an AntiforgeryValidationException is thrown and the request is rejected.

The below minimal api code generates and validates anti-forgery (CSRF) tokens.

using Microsoft.AspNetCore.Antiforgery;
using Microsoft.AspNetCore.Http.HttpResults;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddAntiforgery();

var app = builder.Build();

app.UseAntiforgery();

app.MapGet("/", (HttpContext context, IAntiforgery antiforgery) =>
{
    var token = antiforgery.GetAndStoreTokens(context);
    var html = $"""
      <html>
        <body>
          <form action="/upload" method="POST" enctype="multipart/form-data">
            <input name="{token.FormFieldName}" type="hidden" value="{token.RequestToken}"/>
            <input type="file" name="file" placeholder="Upload an image..." accept=".jpg, .jpeg, .png" />
            <input type="submit" />
          </form> 
        </body>
      </html>
    """;

    return Results.Content(html, "text/html");
});

app.MapPost("/upload", async Task<Results<Ok<string>, BadRequest<string>>> (IFormFile file, HttpContext context, IAntiforgery antiforgery) =>
{
    await antiforgery.ValidateRequestAsync(context);
    var fileSaveName = Guid.NewGuid().ToString("N") + Path.GetExtension(file.FileName);
    await UploadFileWithName(file, fileSaveName);
    return TypedResults.Ok("File uploaded successfully!");
});

async Task UploadFileWithName(IFormFile file, string fileSaveName)
{
    var filePath = GetOrCreateFilePath(fileSaveName);
    await using var fileStream = new FileStream(filePath, FileMode.Create);
    await file.CopyToAsync(fileStream);
}

string GetOrCreateFilePath(string fileName, string filesDirectory = "uploadFiles")
{
    var directoryPath = Path.Combine(app.Environment.ContentRootPath, filesDirectory);
    Directory.CreateDirectory(directoryPath);
    return Path.Combine(directoryPath, fileName);
}

app.Run();

If you run the above code a file upload form will be presented as shown by the below image:

When you view the page source, you can see the form’s code which is given below.

<form action="/upload" method="POST" enctype="multipart/form-data">
        <input name="__RequestVerificationToken" type="hidden" value="CfDJ8CJAiS5rYE9AjJoXkn5DPsi3_4TdjyD6twIrKrDao6kZK04ZNuy20TaQTatwOOD4G2HHrYE4QcNUajMDm-ecYOLGtK2jaQf5opiWXPn6CpBuSzkv0V8UDNkkWKcHLw_TjsuA6X5NKlEPakzpXAJA85k"/>
        <input type="file" name="file" placeholder="Upload an image..." accept=".jpg, .jpeg, .png" />
        <input type="submit" />
</form>

The anti-forgery token code is given inside the hidden input tag:

<input name="__RequestVerificationToken" type="hidden" value="CfDJ8CJAiS5rYE9AjJoXkn5DPsi3_4TdjyD6twIrKrDao6kZK04ZNuy20TaQTatwOOD4G2HHrYE4QcNUajMDm-ecYOLGtK2jaQf5opiWXPn6CpBuSzkv0V8UDNkkWKcHLw_TjsuA6X5NKlEPakzpXAJA85k"/>

Try uploading a file. When anti-forgery token validation is successful then the file is uploaded successfully and we get the message – “File uploaded successfully!”. Check the below image.

Invalid anti-forgery token will give the error:

CryptographicException: The payload was invalid. For more information go to https://aka.ms/aspnet/dataprotectionwarning
AntiforgeryValidationException: The antiforgery token could not be decrypted.
BadHttpRequestException: Invalid anti-forgery token found when reading parameter "IFormFile file" from the request body as form.

Check the below image where we have shown this error:

First the builder.Services.AddAntiforgery() method registers the antiforgery service in your ASP.NET Core dependency injection container. Then we need to tell the app to validate the antiforgery tokens. This is done by the code – app.UseAntiforgery().

The GetAndStoreTokens() method is the primary IAntiforgery method for generating anti-forgery tokens. It creates the tokens needed for CSRF protection and stores the cookie token in the response. A full HTML form is generated in the / endpoint which contains the token. This form is returned in the API response.

Next on the /upload endpoint, the token is validated with the code – await antiforgery.ValidateRequestAsync(context), and when the validation succeed then only the file is uploaded.

Bind to collections and complex types from forms

Here we will see an example that binds a multi-part form input to a complex object. We will also use antiforgery services for validation of antiforgery tokens.

using Microsoft.AspNetCore.Antiforgery;
using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddAntiforgery();

var app = builder.Build();

app.UseAntiforgery();

app.MapGet("/", (HttpContext context, IAntiforgery antiforgery) =>
{
    var token = antiforgery.GetAndStoreTokens(context);
    var html = $"""
        <html><body>
           <form action="/job" method="POST" enctype="multipart/form-data">
               <input name="{token.FormFieldName}" type="hidden" value="{token.RequestToken}" />
               <input type="text" name="name" />
               <input type="date" name="dueDate" />
               <input type="submit" /> 
           </form>
        </body></html>
    """;
    return Results.Content(html, "text/html");
});

app.MapPost("/job", async Task<Results<Ok<Work>, BadRequest<string>>> 
               ([FromForm] Work work, HttpContext context, IAntiforgery antiforgery) =>
{
    try
    {
        await antiforgery.ValidateRequestAsync(context);
        return TypedResults.Ok(work);
    }
    catch (AntiforgeryValidationException e)
    {
        return TypedResults.BadRequest("Invalid antiforgery token");
    }
});

app.Run();

class Work
{
    public string Name { get; set; } = string.Empty;
    public DateTime DueDate { get; set; } = DateTime.Now.Add(TimeSpan.FromDays(1));
}

The endpoint / will present a form with fields name and dueDate. We have to bind these fields to a Work.cs class.

The endpoint /job will bind the submitted form values to the Work class.

We have also used antiforgery services to support the generation and validation of antiforgery tokens.

In the below example binding to a complex type and a list of complex type is performed.

app.MapPost("/items", ([FromForm] List<Item> items) =>
{
    return Results.Ok(items);
});

app.MapPost("/orders", ([FromForm] CreateOrderRequest request) =>
{
    return Results.Ok(request);
});

public class CreateOrderRequest
{
    public string Customer { get; set; } = "";
    public List<Item> Items { get; set; } = [];
}

public class Item
{
    public string Name { get; set; } = "";
    public int Quantity { get; set; }
}

Custom Binding with BindAsync method

BindAsync is useful when:

• You want to combine values from multiple sources (query string, headers, route values, form data, etc.) into a single object.
• You need custom parsing or validation logic during binding.
• You want to keep endpoint handlers clean by moving binding logic into the model itself.

This pattern is especially helpful for reusable request models like paging, filtering, search criteria, or authentication-related context.

The syntax is given below:

public static ValueTask<PagingData?> BindAsync(
    HttpContext context,
    ParameterInfo parameter)

This method is a special convention recognized by Minimal APIs. Whenever a parameter of type PagingData is needed, ASP.NET Core calls this method. Think of it as if the framework internally does:

PagingData pageData = await PagingData.BindAsync(context, parameter);

The parameter HttpContext context contains everything about the request. You can access.

context.Request.Query
context.Request.Headers
context.Request.RouteValues
context.Request.Body
context.Request.Form

The ParameterInfo parameter describes the endpoint parameter being bound. Here the pageData will provides metadata such as:

parameter.Name
parameter.ParameterType
parameter.Attributes

The following code displays SortBy:price, SortDirection:Desc, CurrentPage:10 with the URI /products?SortBy=price&SortDir=Desc&Page=10:

using System.Reflection;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// GET /products?SortBy=price&SortDir=Desc&Page=10
app.MapGet("/products", (PagingData pageData) => $"SortBy:{pageData.SortBy}, " +
       $"SortDirection:{pageData.SortDirection}, CurrentPage:{pageData.CurrentPage}");

app.Run();

public class PagingData
{
    public string? SortBy { get; init; }
    public SortDirection SortDirection { get; init; }
    public int CurrentPage { get; init; } = 1;

    public static ValueTask<PagingData?> BindAsync(HttpContext context,
                                                   ParameterInfo parameter)
    {
        const string sortByKey = "sortBy";
        const string sortDirectionKey = "sortDir";
        const string currentPageKey = "page";

        Enum.TryParse<SortDirection>(context.Request.Query[sortDirectionKey],
                                     ignoreCase: true, out var sortDirection);
        int.TryParse(context.Request.Query[currentPageKey], out var page);
        page = page == 0 ? 1 : page;

        var result = new PagingData
        {
            SortBy = context.Request.Query[sortByKey],
            SortDirection = sortDirection,
            CurrentPage = page
        };

        return ValueTask.FromResult<PagingData?>(result);
    }
}

public enum SortDirection
{
    Default,
    Asc,
    Desc
}

Reading from the Request body and Binding to a complex type

The below code reads from the request body json and binds to a complex Work.cs class. The output returns the work class in json. See the below code.

app.MapPost("/", async (HttpContext context) => {
    if (context.Request.HasJsonContentType()) {
        var work = await context.Request.ReadFromJsonAsync<Work>();
        return Results.Ok(work);
    }
    else {
        return Results.BadRequest();
    }
});

class Work
{
    public string? Name { get; set; }
    public bool IsComplete { get; set; }
}

If the request body contains the following JSON:

{"nameField":"Walk dog", "isComplete":false}

The endpoint returns the following JSON:

{
    "name":"Walk dog",
    "isComplete":false
}

Parameter binding is one of the core features that makes ASP.NET Core Minimal APIs both concise and powerful. Throughout this guide, you’ve seen how the framework automatically binds values from route parameters, query strings, headers, forms, services, and request bodies, as well as how to customize the binding process using attributes like FromRoute, FromQuery, FromHeader, FromForm, FromBody, FromServices, AsParameters, and the BindAsync convention for complex scenarios. Understanding these binding mechanisms allows you to design cleaner endpoints, reduce boilerplate code, and encapsulate request parsing logic into reusable models. By mastering parameter binding, you’ll be able to build Minimal APIs that are easier to read, maintain, and extend while taking full advantage of the flexibility and performance.

The post ASP.NET Core Minimal API Parameter Binding – full guide with codes appeared first on YogiHosting.

ASP.NET CORE – Import Excel file records to SQL Server Database

I have an Excel file containing employee data. The employee fields are Name, Designation, Salary and DOB. The excel file is shown by the below image. You can download this excel file from the GitHub repository itself.

First I have to configure the app for Entity Framework core. I will need it to import the excel’s data to the database. So I create the Employee.cs entity class with the same fields as given in the excel file. These are Name, Designation, Salary and DOB.

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Designation { get; set; }
    public Double Salary { get; set; }
    public DateTime DOB { get; set; }
}

Installing Entity Framework Core

Next, I install the 3 EF Core packages:

Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Design
Install-Package Microsoft.EntityFrameworkCore.Tools

After that, add DbContext file called CompanyContext.cs to the app with the following code.

public class CompanyContext : DbContext
{
    public CompanyContext(DbContextOptions<CompanyContext> options) : base(options)
    {
    }
    public DbSet<Employee> Employee { get; set; }
}

On the appsettings.json file, add the database connection string like given below.

"ConnectionStrings": {
  "DefaultConnection": "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=Company;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False"
}

Finally, register the DbContext in the program class as shown below.

builder.Services.AddDbContext<CompanyContext>(options =>
  options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

Now run EF Core Migrations by executing the following commands one by one.

add-migration Migration1
Update-Database

Two methods to Read Excel in ASP.NET Core

In order to import excel file’s data to the database, we have to first read it. There are 2 methods to read an excel file in ASP.NET Core, these are:

1. System.Data.OleDb library: it is an old method but works very well in reading all types of excel and csv files.
2. DocumentFormat.OpenXml library:it is new library for working with Office Word, Excel, and PowerPoint documents.

Both these libraries are extremely good and maintained by Microsoft so you are not going to face any issues with them. We are going to implement each of these 2 libraries one by one.

Import Excel from System.Data.OleDb

Firstly, install the System.Data.OleDb library package from NuGet.

Run the following NuGet command to install this provider.

Install-Package System.Data.OleDb

With the library installed let’s move to the controller part. Create a new controller called ExcelController.cs. In this controller I will add the code for importing excel file’s data.

Start by injecting “IWebHostEnvironment” and “CompanyContext” on the constructor. IWebHostEnvironment will be needed for reading the “wwwroot” folder and CompanyContext is used for performing EF core operations. Remember that the excel file will first be uploaded to wwwroot/Excel folder and then will be read. Check the below code:

private IWebHostEnvironment hostingEnvironment;
private CompanyContext context;

public ExcelController(IWebHostEnvironment environment, CompanyContext context)
{
    this.context = context;
    hostingEnvironment = environment;
}

After this add action method called “ImportExcel” to the controller. This action method will perform the Import operation. See the code given below.

public IActionResult ImportExcel()
{
    return View();
}

[HttpPost]
public async Task<IActionResult> ImportExcel(IFormFile excelfile)
{
    // By old OleDbConnection way

    string path = Path.Combine(hostingEnvironment.WebRootPath, "Excel/" + excelfile.FileName);
    using (var stream = new FileStream(path, FileMode.Create))
    {
        await excelfile.CopyToAsync(stream);
    }

    string connectionString = string.Empty;
    connectionString = string.Format("Provider=Microsoft.ACE.OLEDB.12.0;Data Source={0};Extended Properties='Excel 12.0 Xml;HDR=YES;'", path);

    using (var conn = new OleDbConnection(connectionString))
    {
        conn.Open();

        string tableName = conn.GetSchema("Tables").Rows[0]["TABLE_NAME"].ToString();

        var query = $"SELECT * FROM [{tableName}]"; // The file name is used in the query
        using (var adapter = new OleDbDataAdapter(query, conn))
        {
            var dataTable = new DataTable();
            adapter.Fill(dataTable);

            List<Employee> records = dataTable.AsEnumerable().Select(row => new Employee
            {
                Name = row.Field<string>("Name"),// Use .Field<T>() for type safety and null handling
                Designation = row.Field<string>("Designation"),
                Salary = row.Field<Double>("Salary"),
                DOB = DateTime.Parse(row.Field<string>("DOB"))
            }).ToList();

            context.AddRange(records);
            context.SaveChanges();
            ViewBag.Result = "Import Successful";
        }
    }

    return View();
}

The action method of type Post receives the excel file uploaded from the view. I then save this file inside the wwwroot/Excel folder by using the IWebHostEnvironment object.

string path = Path.Combine(hostingEnvironment.WebRootPath, "Excel/" + excelfile.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
    await excelfile.CopyToAsync(stream);
}

Next, with System.Data.OleDb provider the excel file is read.

string connectionString = string.Empty;
connectionString = string.Format("Provider=Microsoft.ACE.OLEDB.12.0;Data Source={0};Extended Properties='Excel 12.0 Xml;HDR=YES;'", path);

The reading is done by the select query:

string tableName = conn.GetSchema("Tables").Rows[0]["TABLE_NAME"].ToString();
var query = $"SELECT * FROM [{tableName}]";

The data returned by the select query is filled to a DataTable using SqlDataAdapter. Once the DataTable is filled, it is enumerated to fill the data in a List of Employees and then finally the EF Core AddRange() method is used to insert the data to the database table. See the below code to understand it’s working.

var query = $"SELECT * FROM [{tableName}]"; // The file name is used in the query
using (var adapter = new OleDbDataAdapter(query, conn))
{
    var dataTable = new DataTable();
    adapter.Fill(dataTable);

    List<Employee> records = dataTable.AsEnumerable().Select(row => new Employee
    {
        Name = row.Field<string>("Name"),// Use .Field<T>() for type safety and null handling
        Designation = row.Field<string>("Designation"),
        Salary = row.Field<Double>("Salary"),
        DOB = DateTime.Parse(row.Field<string>("DOB"))
    }).ToList();

    context.AddRange(records);
    context.SaveChanges();
    ViewBag.Result = "Import Successful";
}

Create a new razor view file called ImportExcel.cshtml with the following code.

@{
    ViewData["Title"] = "Import Excel";
}

<h1 class="bg-info text-white">Import Excel</h1>
<a asp-controller="Home" asp-action="Index" class="btn btn-secondary">Back</a>
<h2 class="bg-success text-white">@ViewBag.Result</h2>
<form method="post" enctype="multipart/form-data">
    <div class="form-group">
        <label>Select Excel File</label>
        <input type="file" name="excelfile" class="form-control" />
    </div>
    <button type="submit" class="btn btn-primary">Import</button>
</form>

The view will present the form with a file control to upload the excel file. Once uploaded the file’s data is read and inserted to the database. See the below image which shows this form.

Import Excel from DocumentFormat.OpenXml

Now I will use OpenXml library to read excel file and import it’s data to a SQL Database. So first I have to install OpenXml library from NuGet.

Running the below command can directly install this library to my app.

Install-Package System.Data.OleDb

Important classes and their roles are:

• SpreadsheetDocument: In the Open XML SDK, the SpreadsheetDocument class represents an Excel document package. It is the top-level container used to create, open, and manipulate spreadsheet files (typically .xlsx) programmatically without requiring Microsoft Office to be installed.
• WorkbookPart: it is the central container for an Excel spreadsheet document. It acts as the root for all worksheet-related data, global settings, and shared components.
• WorksheetPart: this class represents the part of a spreadsheet document package that contains all data and characteristics for a single worksheet. It acts as a container for the actual Worksheet element and its related parts.
• OpenXmlReader: it is an abstract base class used to read Office Open XML (OOXML) documents—such as .docx, .xlsx, and .pptx—using a SAX-like (Simple API for XML) approach.

Using these above classes in the code we can read the excel file. So add the ImportExcelOpenXml action method with the following code.

public IActionResult ImportExcelOpenXml()
{
    return View();
}

[HttpPost]
public async Task<IActionResult> ImportExcelOpenXml(IFormFile excelfile)
{
    string path = Path.Combine(hostingEnvironment.WebRootPath, "Excel/" + excelfile.FileName);
    using (var stream = new FileStream(path, FileMode.Create))
    {
        await excelfile.CopyToAsync(stream);
    }

    List<Employee> empList = new List<Employee>();

    using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Open(path, false))
    {
        WorkbookPart workbookPart = spreadsheetDocument.WorkbookPart ?? spreadsheetDocument.AddWorkbookPart();
        WorksheetPart worksheetPart = workbookPart.WorksheetParts.First();
        OpenXmlReader reader = OpenXmlReader.Create(worksheetPart);

        string[] header = { "Name", "Designation", "Salary", "DOB" };
        Employee emp = new Employee();
        int counter = 1;

        while (reader.Read())
        {
            string current = reader.GetText();
            if ((current != "") && (!header.Any(current.Contains)))
            {
                if (counter % 4 == 1)
                {
                    emp.Name = current;
                }
                else if (counter % 4 == 2)
                {
                    emp.Designation = current;
                }
                else if (counter % 4 == 3)
                {
                    emp.Salary = double.Parse(current);
                }
                else
                {
                    emp.DOB = Convert.ToDateTime(current);
                    empList.Add(emp);
                    emp = new Employee();
                }
                counter++;
            }
        }
    }

    context.AddRange(empList);
    context.SaveChanges();
    ViewBag.Result = "Import Successful";

    return View();
}

The excel file is uploaded to the “wwwroot/Excel” folder by the code:

string path = Path.Combine(hostingEnvironment.WebRootPath, "Excel/" + excelfile.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
    await excelfile.CopyToAsync(stream);
}

With the SpreadsheetDocument class, the excel file is read from the “wwwroot/Excel” folder.

using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Open(path, false))
{
}

An OpenXmlReader class is used to read the records in the excel file in cell by cell manner. I also have to use WorkbookPart and WorksheetPart to read the excel’s first sheet before.

WorkbookPart workbookPart = spreadsheetDocument.WorkbookPart ?? spreadsheetDocument.AddWorkbookPart();
WorksheetPart worksheetPart = workbookPart.WorksheetParts.First();
OpenXmlReader reader = OpenXmlReader.Create(worksheetPart);

I use my own custom logic in order to add all the records of the excel file in a list of employee object. To understand this code, see a string array class object – “header” for storing the header names of employee records.

string[] header = { "Name", "Designation", "Salary", "DOB" };

And a counter that starts from 1. I then uses them in the while loop, which is reading the cells of the excel one by one, to check if the current cell is not containing any of the header string and also the cell it not empty. This means the cell value is for either the Name, Designation, Salary or DOB field.

I then use counter % 4 to find out if the value is 1 which is for “Name” field, value of 2 for “Designation” field, value of 3 for “Salary” and value of 4 for “DOB” field.

See the below code.

while (reader.Read())
{
    string current = reader.GetText();
    if ((current != "") && (!header.Any(current.Contains)))
    {
        if (counter % 4 == 1)
        {
            emp.Name = current;
        }
        else if (counter % 4 == 2)
        {
            emp.Designation = current;
        }
        else if (counter % 4 == 3)
        {
            emp.Salary = double.Parse(current);
        }
        else
        {
            emp.DOB = Convert.ToDateTime(current);
            empList.Add(emp);
            emp = new Employee();
        }
        counter++;
    }
}

With the List of Employees now containing all the employee records, I am using EF Core AddRange() method to insert this to the database. This way the import work is done.

context.AddRange(empList);
context.SaveChanges();
ViewBag.Result = "Import Successful";

Next, add the razor view file called ImportExcelOpenXml.cshtml which will contain a file upload control for uploading and reading the excel file. The code is given below.

@{
    ViewData["Title"] = "Import Excel";
}

<h1 class="bg-info text-white">Import Excel (by OpenXml)</h1>
<a asp-controller="Home" asp-action="Index" class="btn btn-secondary">Back</a>
<h2 class="bg-success text-white">@ViewBag.Result</h2>
<form method="post" enctype="multipart/form-data">
    <div class="form-group">
        <label>Select Excel File</label>
        <input type="file" name="excelfile" class="form-control" />
    </div>
    <button type="submit" class="btn btn-primary">Import</button>
</form>

Run the app, you will be presented with a file upload control. Select the excel file whose data is to be imported to the database.

ASP.NET CORE – Export Excel file records from SQL Server Database

I will now perform the export of Employee records from the SQL Server database to an Excel file. I will show all the Employees in an HTML Table. This HTML table will have a checkbox against each record, for letting users to select the employees whose data needs to be saved to the excel file. After the employees are selected, the user clicks a button to generate this excel file. The excel file will be downloaded by the browser.

The below image shows this table with checkboxes:

I will have to add a new ViewModel called EmployeeViewModel.cs. This is the same like Employee.cs class except that a new property “IsChecked” is added for the checkboxes. Through these checkboxes, user can select the records that needs to be exported to an excel file.

public class EmployeeViewModel
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Designation { get; set; }
    public Double Salary { get; set; }
    public DateTime DOB { get; set; }
    public bool IsChecked { get; set; }
}

Add a new action method called “ExportExcel” to the controller. This action method reads the employee records from the database and returns them to the view where they will be displayed in an HTML Table.

public IActionResult ExportExcel()
{
    List<Employee> eList = context.Employee.ToList();

    List<EmployeeViewModel> records = eList.AsEnumerable().Select(row => new EmployeeViewModel
    {
        Id = row.Id,
        Name = row.Name,
        Designation = row.Designation,
        Salary = row.Salary,
        DOB = row.DOB
    }).ToList();

    return View(records);
}

Next, add the razor view ExportExcel.cshtml which shows the employees in a table along with a checkbox to make the selection. The code is given below.

@{
    ViewData["Title"] = "Export Excel";
}
@model List<EmployeeViewModel>

<h1 class="bg-info text-white">Export Excel</h1>
  
<a asp-controller="Home" asp-action="Index" class="btn btn-secondary">Back</a>

<form method="post">
    <table class="table table-sm table-bordered">
        <tr>
            <th>Id</th>
            <th>Name</th>
            <th>Designation</th>
            <th>Salary</th>
            <th>Date of Birth</th>
            <th></th>
        </tr>

        @for (int i = 0; i < Model.Count; i++)
        {
            <tr>
                <td>
                    <label asp-for="@Model[i].Id">@Model[i].Id</label>
                    <input type="hidden" asp-for="@Model[i].Id" />
                </td>
                <td><label asp-for="@Model[i].Name">@Model[i].Name</label></td>
                <td><label asp-for="@Model[i].Name">@Model[i].Designation</label></td>
                <td><label asp-for="@Model[i].Name">@Model[i].Salary</label></td>
                <td><label asp-for="@Model[i].Name">@Model[i].DOB</label></td>
                <td><input type="checkbox" asp-for="@Model[i].IsChecked" /></td>
            </tr>
        }
    </table>
    <button type="submit" class="btn btn-primary">Export Excel</button>
</form>

In the above code the html table is created to show all the employee records. Also note the checkbox given against each employee to enable user to select the employee records.

<input type="checkbox" asp-for="@Model[i].IsChecked" />

A hidden field is also added which will transfer the Ids of employees to the post action method in the controller.

<input type="hidden" asp-for="@Model[i].Id" />

Next, add the ExportExcel action of type POST. This action method will perform the export procedure. See the below code.

[HttpPost]
public IActionResult ExportExcel(List<EmployeeViewModel> empList)
{
    var selectedRecords = empList.Where(r => r.IsChecked).Select(r => r.Id).ToList();
    var emp = context.Employee.Where(o => selectedRecords.Contains(o.Id)).ToList();

    string path = Path.Combine(hostingEnvironment.WebRootPath, "Excel/mydata.xlsx");

    using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Create(path, SpreadsheetDocumentType.Workbook))
    {

        // Add a WorkbookPart to the document.
        WorkbookPart workbookPart = spreadsheetDocument.AddWorkbookPart();
        workbookPart.Workbook = new Workbook();

        // Add a WorksheetPart to the WorkbookPart.
        WorksheetPart worksheetPart = workbookPart.AddNewPart<WorksheetPart>();
        worksheetPart.Worksheet = new Worksheet(new SheetData());

        SheetData sheetData = worksheetPart.Worksheet.GetFirstChild<SheetData>();

        // Add Sheets to the Workbook.
        Sheets sheets = workbookPart.Workbook.AppendChild(new Sheets());

        // Append a new worksheet and associate it with the workbook.
        Sheet sheet = new Sheet() { Id = workbookPart.GetIdOfPart(worksheetPart), SheetId = 1, Name = "mySheet" };
        sheets.Append(sheet);

        // Add Data
        Row row = new Row();
        row.Append(new Cell() { CellValue = new CellValue("Id"), DataType = CellValues.String });
        row.Append(new Cell() { CellValue = new CellValue("Name"), DataType = CellValues.String });
        row.Append(new Cell() { CellValue = new CellValue("Destination"), DataType = CellValues.String });
        row.Append(new Cell() { CellValue = new CellValue("Salary"), DataType = CellValues.String });
        row.Append(new Cell() { CellValue = new CellValue("DOB"), DataType = CellValues.String });
        sheetData.Append(row);

        foreach (var e in emp)
        {
            row = new Row();
            row.Append(new Cell() { CellValue = new CellValue(e.Id), DataType = CellValues.Number });
            row.Append(new Cell() { CellValue = new CellValue(e.Name), DataType = CellValues.String });
            row.Append(new Cell() { CellValue = new CellValue(e.Designation), DataType = CellValues.String });
            row.Append(new Cell() { CellValue = new CellValue(e.Salary), DataType = CellValues.String });
            row.Append(new Cell() { CellValue = new CellValue(e.DOB), DataType = CellValues.Date });
            sheetData.Append(row);
        }

        workbookPart.Workbook.Save();
    }

    var contentType = "application/octet-stream";
    return PhysicalFile(path, contentType, Path.GetFileName(path));
}

To understand the above code, first I am finding the checked employee ids and reading these employee records in a list of employee object by the name “emp”.

var selectedRecords = empList.Where(r => r.IsChecked).Select(r => r.Id).ToList();
var emp = context.Employee.Where(o => selectedRecords.Contains(o.Id)).ToList();

Next, with SpreadsheetDocument class, I am creating an empty excel file which will contain the checked employee records data.

using (SpreadsheetDocument spreadsheetDocument = SpreadsheetDocument.Create(path, SpreadsheetDocumentType.Workbook))
{
}

You will find the WorkbookPart and WorksheetPart that are adding a sheet to the excel file.

WorkbookPart workbookPart = spreadsheetDocument.AddWorkbookPart();
workbookPart.Workbook = new Workbook();

WorksheetPart worksheetPart = workbookPart.AddNewPart<WorksheetPart>();
worksheetPart.Worksheet = new Worksheet(new SheetData());

Next, with the SheetData and Sheet classes the employee data is appended to this new sheet.

SheetData sheetData = worksheetPart.Worksheet.GetFirstChild<SheetData>();
Sheets sheets = workbookPart.Workbook.AppendChild(new Sheets());

Sheet sheet = new Sheet() { Id = workbookPart.GetIdOfPart(worksheetPart), SheetId = 1, Name = "mySheet" };
sheets.Append(sheet);

I now use the “Row” class to add the Employee headers which are Id, Name, Destination, Salary, and DOB. And then looping through all the records that are there in the list of employee objects, and adding them to the row. The row is appended to the sheet with the sheetData.Append(row) method.

Row row = new Row();
 row.Append(new Cell() { CellValue = new CellValue("Id"), DataType = CellValues.String });
 row.Append(new Cell() { CellValue = new CellValue("Name"), DataType = CellValues.String });
 row.Append(new Cell() { CellValue = new CellValue("Destination"), DataType = CellValues.String });
 row.Append(new Cell() { CellValue = new CellValue("Salary"), DataType = CellValues.String });
 row.Append(new Cell() { CellValue = new CellValue("DOB"), DataType = CellValues.String });
 sheetData.Append(row);

 foreach (var e in emp)
 {
     row = new Row();
     row.Append(new Cell() { CellValue = new CellValue(e.Id), DataType = CellValues.Number });
     row.Append(new Cell() { CellValue = new CellValue(e.Name), DataType = CellValues.String });
     row.Append(new Cell() { CellValue = new CellValue(e.Designation), DataType = CellValues.String });
     row.Append(new Cell() { CellValue = new CellValue(e.Salary), DataType = CellValues.String });
     row.Append(new Cell() { CellValue = new CellValue(e.DOB), DataType = CellValues.Date });
     sheetData.Append(row);
 }

At last the excel file is downloaded with the below code.

var contentType = "application/octet-stream";
return PhysicalFile(path, contentType, Path.GetFileName(path));

Its now time to run the app and test the feature. I select the records no 1, 6, 8 and 10 and then click the button to generate the excel file. See the below image.

The excel file is generated and is shown below.

In this tutorial I created the full features of Import and Export excel in ASP.NET Core. I explained both the method of OpenXml and System.Data.OleDb to read the excel file. The full source codes of this tutorial is available in my GitHub repository. The link is given at the top.

The post How to Import Export Excel file in ASP.NET Core appeared first on YogiHosting.

In this tutorial we are going to learn how to Import and Export data from a CSV file in ASP.NET Core. The whole source codes of this tutorial can be downloaded from my GitHub repository.

ASP.NET CORE – Import CSV file records to SQL Server Database

I have a CSV file containing employee data. The employee fields are Name, Designation, Salary and DOB. The CSV file is shown by the below image. You can download this csv file from the GitHub repository itself.

Let’s import this CSV file in ASP.NET Core.

Firstly, I install the System.Data.OleDb package from NuGet. It is the Data Provider for OLE DB data sources and will be used to read the CSV file.

Run the following NuGet command to install this provider.

Install-Package System.Data.OleDb

Next, I create the Employee.cs entity class with the same fields as given in the csv file. These are Name, Designation, Salary and DOB.

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Designation { get; set; }
    public Double Salary { get; set; }
    public DateTime DOB { get; set; }
}

Installing Entity Framework Core

Since I will insert the CSV file’s data to the SQL Server database therefore I will need Entity Framework Core. So install the 3 packages:

Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Design
Install-Package Microsoft.EntityFrameworkCore.Tools

Next, add DbContext file called CompanyContext.cs to the app with the following code.

public class CompanyContext : DbContext
{
    public CompanyContext(DbContextOptions<CompanyContext> options) : base(options)
    {
    }
    public DbSet<Employee> Employee { get; set; }
}

To the appsettings.json file, add the database connection string like given below.

"ConnectionStrings": {
  "DefaultConnection": "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=Company;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False"
}

Register the DbContext in the program class as shown below.

builder.Services.AddDbContext<CompanyContext>(options =>
  options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

With everything set up, perform the EF Core Migrations by running the following commands one by one.

add-migration Migration1
Update-Database

Create the View and the Controller

Create a new controller called CsvController.cs. In this controller I will add the code for importing csv file’s data.

Firstly, inject “IWebHostEnvironment” and “CompanyContext” on the constructor. IWebHostEnvironment will be needed for reading the wwwroot folder and CompanyContext is used for performing EF core operations.

private IWebHostEnvironment hostingEnvironment;
private CompanyContext context;

public CsvController(IWebHostEnvironment environment, CompanyContext context)
{
    this.context = context;
    hostingEnvironment = environment;
}

After this add action method called “ImportCsv” to the controller. This action method will perform the CSV Import operation. See the code given below.

public IActionResult ImportCsv()
{
    return View();
}

[HttpPost]
public async Task<IActionResult> ImportCsv(IFormFile csvfile)
{
    // By old OleDbConnection way

    string path = Path.Combine(hostingEnvironment.WebRootPath, "CSV/" + csvfile.FileName);
    using (var stream = new FileStream(path, FileMode.Create))
    {
        await csvfile.CopyToAsync(stream);
    }

    string folderPath = Path.Combine(hostingEnvironment.WebRootPath, "CSV"); 
    string connectionString = $@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={folderPath};Extended Properties=""text;HDR=YES;FMT=Delimited;IMEX=1;MaxScanRows=0""";

    using (var conn = new OleDbConnection(connectionString))
    {
        conn.Open();
        var query = $"SELECT * FROM [{csvfile.FileName}]"; // The file name is used in the query
        using (var adapter = new OleDbDataAdapter(query, conn))
        {
            var dataTable = new DataTable();
            adapter.Fill(dataTable);

            List<Employee> records = dataTable.AsEnumerable().Select(row => new Employee
            {
                Name = row.Field<string>("Name"),// Use .Field<T>() for type safety and null handling
                Designation = row.Field<string>("Designation"),
                Salary = row.Field<Double>("Salary"),
                DOB = row.Field<DateTime>("DOB")
            }).ToList();

            context.AddRange(records);
            context.SaveChanges();
            ViewBag.Result = "Import Successful";
        }
    }

    return View();
}

The action method of type Post receives the csv file uploaded from the view. I then save this csv file inside the wwwroot/CSV folder by using the IWebHostEnvironment object.

string path = Path.Combine(hostingEnvironment.WebRootPath, "CSV/" + csvfile.FileName);
using (var stream = new FileStream(path, FileMode.Create))
{
    await csvfile.CopyToAsync(stream);
}

Next, with System.Data.OleDb provider the CSV file is read. Note that this csv file is stored inside the wwwroot/CSV folder.

string folderPath = Path.Combine(hostingEnvironment.WebRootPath, "CSV");
string connectionString = $@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={folderPath};Extended Properties=""text;HDR=YES;FMT=Delimited;IMEX=1;MaxScanRows=0""";

The actual CSV reading code is given below where a select query – SELECT * FROM [{csvfile.FileName}] is executed to read the CSV data. Then the data is filled to a DataTable using SqlDataAdapter.

Once the DataTable is filled, it is enumerated to fill the data in a List of Employees and then finally the EF Core AddRange() method is used to insert the data to the database table. See the below code to understand it’s working.

using (var conn = new OleDbConnection(connectionString))
{
    conn.Open();
    var query = $"SELECT * FROM [{csvfile.FileName}]"; // The file name is used in the query
    using (var adapter = new OleDbDataAdapter(query, conn))
    {
        var dataTable = new DataTable();
        adapter.Fill(dataTable);

        List<Employee> records = dataTable.AsEnumerable().Select(row => new Employee
        {
            Name = row.Field<string>("Name"),// Use .Field<T>() for type safety and null handling
            Designation = row.Field<string>("Designation"),
            Salary = row.Field<Double>("Salary"),
            DOB = row.Field<DateTime>("DOB")
        }).ToList();

        context.AddRange(records);
        context.SaveChanges();
        ViewBag.Result = "Import Successful";
    }
}

Create a new razor view file called ImportCsv.cshtml with the following code.

@{
    ViewData["Title"] = "Import CSV";
}

<h1 class="bg-info text-white">Import CSV</h1>
<a asp-controller="Home" asp-action="Index" class="btn btn-secondary">Back</a>
<h2 class="bg-success text-white">@ViewBag.Result</h2>
<form method="post" enctype="multipart/form-data">
    <div class="form-group">
        <label>Select CSV File</label>
        <input type="file" name="csvfile" class="form-control" />
    </div>
    <button type="submit" class="btn btn-primary">Import</button>
</form>

Let’s run the app to test the CSV import feature. The form will contain a file upload where I need to select the CSV file. Click the import button to perform the import task.

Lets check the Employee table, where I can see all the data is successfully inserted to the table.

So this successfully completes the CSV import feature in ASP.NET Core. Next, I will perform the CSV export in ASP.NET Core.

ASP.NET CORE – Export CSV file records from SQL Server Database

I will now perform the export of Employee records from the SQL Server database to a CSV file. First of all I will show all the Employees in an HTML Table. This HTML table will have a checkbox against each record, for enabling user to select the employees whose data needs to be saved to a CSV file. After the employees are selected, the user clicks a button to generate this CSV file.

The below image shows this:

Start by adding a new ViewModel called EmployeeViewModel.cs. This is the same like Employee.cs class except that a new property “IsChecked” is added for the checkboxes. Recall that I will be adding checkboxes against each record for enabling the user to select the records from the html table.

public class EmployeeViewModel
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Designation { get; set; }
    public Double Salary { get; set; }
    public DateTime DOB { get; set; }
    public bool IsChecked { get; set; }
}

Add a new action method called “ExportCsv” to the controller. This action method reads the employee records from the database and returns them to the view where they will be displayed in an HTML Table.

public IActionResult ExportCsv()
{
    List<Employee> eList = context.Employee.ToList();

    List<EmployeeViewModel> records = eList.AsEnumerable().Select(row => new EmployeeViewModel
    {
        Id = row.Id,
        Name = row.Name,
        Designation = row.Designation,
        Salary = row.Salary,
        DOB = row.DOB
    }).ToList();

    return View(records);
}

Next, add the razor view file called ExportCsv.html with the following code.

@{
    ViewData["Title"] = "Export CSV";
}

@model List<EmployeeViewModel>

<h1 class="bg-info text-white">Export CSV</h1>
  
<a asp-controller="Home" asp-action="Index" class="btn btn-secondary">Back</a>

<form method="post">
    <table class="table table-sm table-bordered">
        <tr>
            <th>Id</th>
            <th>Name</th>
            <th>Designation</th>
            <th>Salary</th>
            <th>Date of Birth</th>
            <th></th>
        </tr>

        @for (int i = 0; i < Model.Count; i++)
        {
            <tr>
                <td>
                    <label asp-for="@Model[i].Id">@Model[i].Id</label>
                    <input type="hidden" asp-for="@Model[i].Id" />
                </td>
                <td><label asp-for="@Model[i].Name">@Model[i].Name</label></td>
                <td><label asp-for="@Model[i].Name">@Model[i].Designation</label></td>
                <td><label asp-for="@Model[i].Name">@Model[i].Salary</label></td>
                <td><label asp-for="@Model[i].Name">@Model[i].DOB</label></td>
                <td><input type="checkbox" asp-for="@Model[i].IsChecked" /></td>
            </tr>
        }
    </table>
    <button type="submit" class="btn btn-primary">Export</button>
</form>

In the above code the html table is created to show all the employee records. Also note the checkbox given against each employee to enable user to select the employee records.

<input type="checkbox" asp-for="@Model[i].IsChecked" />

Also notice a hidden field which will transfer the Ids of employees to the post action method in the controller.

<input type="hidden" asp-for="@Model[i].Id" />

Next, add the ExportCsv action of type POST. This action method will perform the creation of CSV file from the selected employee records. See the below code.

[HttpPost]
public IActionResult ExportCsv(List<EmployeeViewModel> empList)
{
    var selectedRecords = empList.Where(r => r.IsChecked).Select(r => r.Id).ToList();
    var emp = context.Employee.Where(o => selectedRecords.Contains(o.Id)).ToList();

    var sb = new StringBuilder();

    sb.Append("Id" + ',' + "Name" + ',' + "Designation" + ',' + "Salary" + ',' + "DOB"); // header
    sb.Append("\r\n"); // New line after header

    foreach (var e in emp)
    {
        sb.Append(e.Id.ToString() + ',' + e.Name + ',' + e.Designation + ',' + e.Salary + ',' + e.DOB);
        sb.Append("\r\n");
    }

    return File(Encoding.UTF8.GetBytes(sb.ToString()), "text/csv", "exportdata.csv");
}

I first read all the employee Id that contains the IsChecked property value to be true. These are the selected employees.

var selectedRecords = empList.Where(r => r.IsChecked).Select(r => r.Id).ToList();

Then with EF Core, I read these Id’s records from the database.

var emp = context.Employee.Where(o => selectedRecords.Contains(o.Id)).ToList();

With the StringBuilder, I create a CSV file (which is comma separated), adding both the header row and the employee data of selected employees.

Then converting the data to a CSV file and downloading this file to the client browser from the memory.

return File(Encoding.UTF8.GetBytes(sb.ToString()), "text/csv", "exportdata.csv");

I can now select the employee records for generating the CSV file. Lets say I select employee with Id 2 and 10. The generated CSV will contain only these 2 records. Check the generated CSV file image given below.

In the tutorial I created both the CSV import and export CSV feature in ASP.NET Core. I hope you understood each and every part of it. You can use the source codes of this tutorial by downloading the GitHub repository. The link is given at the top.

The post How to Import Export CSV file in ASP.NET Core appeared first on YogiHosting.

The given image explains the full process of PDF generation:

Let’s generate a complete PDF file with MigraDoc in ASP.NET Core version 10.0

MigraDoc Code Structure

The structure of MigraDoc contains 3 parts:

1. Document: it is the parent object which contains sections.
2. Section: all contents of a document are organized in sections. Sections contains other objects like table and paragraph.
3. PdfDocumentRenderer: it takes a Document object, formats it properly (layout, fonts, pages) and outputs a PDF file

The code structure is given below.

var document = new Document();
var section = document.AddSection();

var heading = section.AddParagraph("Test PDF");

var pdfRenderer = new PdfDocumentRenderer();

pdfRenderer.Document = document;

pdfRenderer.RenderDocument();
pdfRenderer.Save("SimpleDocument.pdf");

Generate PDF file with MigraDoc in ASP.NET Core version 10

To see how MigraDoc works we will generate a complete credit card statement of a bank customer in ASP.NET Core version 10.0. Once completed the PDF file will look as shown in the below image.

In Visual Studio create a new project and select the template called ASP.NET Core Web App (Model-View-Controller).

First, we need to install the package called PDFsharp-MigraDoc from NuGet.

Next, import the necessary namespaces on the controller.

using MigraDoc.Rendering;
using MigraDocTutorial.Models;
using PdfSharp.Fonts;
using MigraDoc.DocumentObjectModel;

Now, open the HomeController file and in Index action we add MigraDoc codes as shown below.

public class HomeController : Controller
{
    private IWebHostEnvironment hostingEnvironment;

    public HomeController(IWebHostEnvironment environment)
    {
        hostingEnvironment = environment;
    }

    public IActionResult Index()
    {
        string imagePath = Path.Combine(hostingEnvironment.WebRootPath, "Images");

        var document = new Document();
        var section = document.AddSection();

        GlobalFontSettings.UseWindowsFontsUnderWindows = true;

        var heading = section.AddParagraph("Your Credit Card Statement Report has been Generated");

        heading.Format.OutlineLevel = OutlineLevel.Level1;
        heading.Format.Font.Size = 25;

        // Add line below the heading
        heading.Format.Borders.Bottom.Width = 1;
        heading.Format.SpaceAfter = "30pt";

        // Add table.
        var table = section.AddTable();

        // Add first column.
        var columnA = table.AddColumn(Unit.FromCentimeter(6));

        // Add second column.
        var columnB = table.AddColumn(Unit.FromCentimeter(12));
        
        // Add first row.
        var row1 = table.AddRow();

        // Add paragraph to first cell of row1.
        var cellA1 = row1[0];

        document.ImagePath = imagePath;
        var image = cellA1.AddImage("woman.jpg");
        image.Width = Unit.FromPoint(150);
        image.Height = Unit.FromPoint(150);

        // Add paragraph to second cell of row1.
        var cellB1 = row1[1];
        cellB1.AddParagraph("Name: Mrs. Grace Kelly");
        cellB1.AddParagraph("Address: House 20, 31 drowning street, London (UK)");
        cellB1.AddParagraph("Occupation: Doctor");
        cellB1.AddParagraph("Age: 30");
        cellB1.Format.Font.Size = 25;
        cellB1.Format.Font.Color = Colors.Red;

        var heading1 = section.AddParagraph("This month's transation in your Credit Card !");
        heading1.Format.Font.Size = 20;
        heading1.Format.Font.Color = Colors.BurlyWood;

        // Add line below the heading
        heading1.Format.Borders.Bottom.Width = 1;
        heading1.Format.SpaceBefore = "30pt";
        heading1.Format.SpaceAfter = "30pt";

        var table2 = section.AddTable();
        table2.Borders.Visible = true;

        table2.AddColumn("3cm");
        table2.AddColumn("3cm");
        table2.AddColumn("3cm");
        table2.AddColumn("3cm");
        table2.AddColumn("3cm");

        var row1Table2 = table2.AddRow();
        row1Table2.HeadingFormat = true;
        row1Table2.Format.Font.Color = Colors.BlueViolet;
        row1Table2.Shading.Color = Colors.LightGray;

        row1Table2[0].AddParagraph("S.No");
        row1Table2[1].AddParagraph("Merchant");
        row1Table2[2].AddParagraph("Item");
        row1Table2[3].AddParagraph("Cost");
        row1Table2[4].AddParagraph("Date");

        var row2Table2 = table2.AddRow();
        row2Table2[0].AddParagraph("1");
        row2Table2[1].AddParagraph("NYC Junction");
        row2Table2[2].AddParagraph("Fruits");
        row2Table2[3].AddParagraph("$100.00");
        row2Table2[4].AddParagraph("June 1");

        var row3Table2 = table2.AddRow();
        row3Table2[0].AddParagraph("2");
        row3Table2[1].AddParagraph("David Store");
        row3Table2[2].AddParagraph("Napkins");
        row3Table2[3].AddParagraph("5.90");
        row3Table2[4].AddParagraph("June 3");

        var row4Table2 = table2.AddRow();
        row4Table2[0].AddParagraph("3");
        row4Table2[1].AddParagraph("Singhs");
        row4Table2[2].AddParagraph("Toys");
        row4Table2[3].AddParagraph("$99.99");
        row4Table2[4].AddParagraph("June 9");

        var row5Table2 = table2.AddRow();
        row5Table2[0].AddParagraph("4");
        row5Table2[1].AddParagraph("Seven 11");
        row5Table2[2].AddParagraph("Grocery");
        row5Table2[3].AddParagraph("$140.00");
        row5Table2[4].AddParagraph("June 15");

        var row6Table2 = table2.AddRow();
        row6Table2[0].AddParagraph("5");
        row6Table2[1].AddParagraph("Carlos Pharmacy");
        row6Table2[2].AddParagraph("Drugs");
        row6Table2[3].AddParagraph("$60.00");
        row6Table2[4].AddParagraph("June 25");

        var custName = section.AddParagraph("Hello Grace,");
        custName.Format.SpaceBefore = "30pt";
        custName.Format.SpaceAfter = "20pt";
        section.AddParagraph("Thank you for being our valuable customer. We hope our letter finds you in the best of health and wealth.\n\nYours Sincerely.\nICICI Bank");

        // Create a PDF renderer for the MigraDoc document.
        var pdfRenderer = new PdfDocumentRenderer();

        // Associate the MigraDoc document with a renderer.
        pdfRenderer.Document = document;

        // Layout and render document to PDF.
        pdfRenderer.RenderDocument();
        // Save the document.
        pdfRenderer.Save("SimpleDocument.pdf");

        return View();
    }
}

The above code is a complete code which will generate the Credit Card statement PDF file. Lets understand the code part by part.

Document and Section

In the above code we defined the Document and added a section to it. The code which does this work is given below.

var document = new Document();
var section = document.AddSection();

We then specified MigraDoc to use windows fonts by the below code:

GlobalFontSettings.UseWindowsFontsUnderWindows = true;

public HomeController(IWebHostEnvironment environment)
{
    hostingEnvironment = environment;
}

string imagePath = Path.Combine(hostingEnvironment.WebRootPath, "Images");

Heading

From the AddParagraph method we added the text – “Your Credit Card Statement Report has been Generated”. To make it big size we gave it OutlineLevel and font size 25. We also added a border of width 1pt below it and gave spacing of 30pt after it. See the below code.

var heading = section.AddParagraph("Your Credit Card Statement Report has been Generated");

heading.Format.OutlineLevel = OutlineLevel.Level1;
heading.Format.Font.Size = 25;

// Add line below the heading
heading.Format.Borders.Bottom.Width = 1;
heading.Format.SpaceAfter = "30pt";

The above code will generate the following as shown by the below image.

MigraDoc Table

Next, we defined a table which will contain 2 columns. The left column will contain the customer image and the right column will contain the customer name, address and other details. The below image shown the details.

The code which does this thing is given below.

// Add table.
var table = section.AddTable();

// Add first column.
var columnA = table.AddColumn(Unit.FromCentimeter(6));

// Add second column.
var columnB = table.AddColumn(Unit.FromCentimeter(12));

// Add first row.
var row1 = table.AddRow();

// Add paragraph to first cell of row1.
var cellA1 = row1[0];

document.ImagePath = imagePath;
var image = cellA1.AddImage("woman.jpg");
image.Width = Unit.FromPoint(150);
image.Height = Unit.FromPoint(150);

// Add paragraph to second cell of row1.
var cellB1 = row1[1];
cellB1.AddParagraph("Name: Mrs. Grace Kelly");
cellB1.AddParagraph("Address: House 20, 31 drowning street, London (UK)");
cellB1.AddParagraph("Occupation: Doctor");
cellB1.AddParagraph("Age: 30");
cellB1.Format.Font.Size = 25;
cellB1.Format.Font.Color = Colors.Red;

var heading1 = section.AddParagraph("This month's transation in your Credit Card !");
heading1.Format.Font.Size = 20;
heading1.Format.Font.Color = Colors.BurlyWood;

// Add line below the heading
heading1.Format.Borders.Bottom.Width = 1;
heading1.Format.SpaceBefore = "30pt";
heading1.Format.SpaceAfter = "30pt";

If we explain the above code, it starts by adding the table to the section. Then adding the 2 columns of width 6cms and 12cms to the table.

var table = section.AddTable();
var columnA = table.AddColumn(Unit.FromCentimeter(6));
var columnB = table.AddColumn(Unit.FromCentimeter(12));

After that we added a row and the first cell to the row. Note that the first cell has index 0 and second one has index 1.

var row1 = table.AddRow();
var cellA1 = row1[0];

The first cell will contain the image of the customer so we have to provide the image path i.e. wwwroot/Images. See below code.

document.ImagePath = imagePath;

Next, we add the image of the customer with dimension 150pt * 150pt.

var image = cellA1.AddImage("woman.jpg");
image.Width = Unit.FromPoint(150);
image.Height = Unit.FromPoint(150);

The second cell is also added in the same way where we have shown the customer details. See the below code.

var cellB1 = row1[1];
cellB1.AddParagraph("Name: Mrs. Grace Kelly");
cellB1.AddParagraph("Address: House 20, 31 drowning street, London (UK)");
cellB1.AddParagraph("Occupation: Doctor");
cellB1.AddParagraph("Age: 30");
cellB1.Format.Font.Size = 25;
cellB1.Format.Font.Color = Colors.Red;

After this we added another table which contains 5 columns to show the credit card transaction details of the customer. The below image shows this.

There is nothing new to this code and it is self explanatory.

The next part of the pdf contains the final message to the customer. The code which does this thing is given below.

var custName = section.AddParagraph("Hello Grace,");
custName.Format.SpaceBefore = "30pt";
custName.Format.SpaceAfter = "20pt";
section.AddParagraph("Thank you for being our valuable customer. We hope our letter finds you in the best of health and wealth.\n\nYours Sincerely.\nICICI Bank");

The below image shown this portion of the pdf.

MigraDoc PDF Rendering

We have added all the details to the pdf. We now have to save the pdf file. For this we use the PdfDocumentRenderer object to render the pdf. The pdf file will be named as “SimpleDocument.pdf” and will be saved on the root of the app.

Well that’s it we just completed the full pdf generation with MigraDoc. You can create any type of pdf with this library free of charge. Download the source codes from our GitHub repo (link at the top) and start using this library.

The post How to create PDF files in ASP.NET Core with MigraDoc appeared first on YogiHosting.

When building modern web applications with ASP.NET Core, especially in microservices architectures, direct communication between services can lead to tight coupling and reduced flexibility. RabbitMQ helps solve this by acting as an intermediary that manages message queues. Instead of services calling each other directly, they send messages to a queue, which are then consumed by other services when they are ready. This approach enhances fault tolerance and allows systems to scale independently.

Using RabbitMQ in ASP.NET Core typically involves producing messages (publishers) and consuming them (consumers). For example, an “Order” Microservice (Publisher) takes an order from a customer, and publishes a message to RabbitMQ about this order. RabbitMQ sends this Order message to the “Shipping” Microservice (Consumer), so that the shipping microservice can ship the order to the customer. This asynchronous workflow ensures that the whole app remains responsive while heavy tasks are handled separately.

ASP.NET Core Microservices example with RabbitMQ

In this .NET example we will use RabbitMQ as a message broker for Microservices communication. There will be 2 Microservices build on ASP.NET Core these are:

• Order Microservice (Publisher)- that will take the customer order and produce the message regarding the order for RabbitMQ. RabbitMQ will send this order message to the Shipping Mircoservice.
• Shipping Microservice (Consumer) – will get the Order message from RabbitMQ regarding the Order message, and will ship the product to the customer.

We have explained the whose process in the below image.

Installing RabbiMQ

We will install RabbitMQ through Docker. This is a very fast process. We just run the following command on command prompt or Powershell.

docker run -it --rm --name rabbitmq -p 5672:5672 -p 15672:15672 rabbitmq:4-management

Check the below image which shows this command.

In 1 to 2 minutes RabbitMQ image will be downloaded on our pc and will run from a docker container. Open the RabbitMQ url – http://localhost:15672/ on the browser. Then for both username and password enter “guest” and click the login button.

Once login we will see tabs for – Overview, Connections, Channels, Exchanged, Queues and Streams and Admin. Navigate to any of them shows the specific details.

In RabbitMQ, a channel is a lightweight virtual connection that runs on top of a real connection. It’s the main way your application actually interacts with RabbitMQ to send and receive messages.

A connection is a fundamental link established between your application (such as an ASP.NET Core MVC) and the RabbitMQ server.

If you navigate to Channels and Connections they will show nothing since we haven’t yes interacted with RabbitMQ with our ASP.NET Core MVC app.

In RabbitMQ, an exchange is the component responsible for receiving messages from producers and deciding how to route them to queues. It acts like a smart message router. An exchange receives messages from a producer (publisher), uses rules (called bindings) to determine where messages go and Sends messages to one or more queues. Note that producers never send messages directly to queues—they always send them to an exchange.

Navigate to “Exchanges” where you will find few exchanges already present, these are:

• Default Exchange : “AMQP default” usually refers to the default exchange that is automatically created by the broker when it starts. It’s part of the AMQP standard.
• Direct Exchange : Routes messages based on an exact match of the routing key.
• Fanout Exchange : Sends messages to all bound queues.
• Topic Exchange : Routes messages using pattern matching.
• Headers Exchange : Routes based on message headers instead of routing key.

Queues and Streams are two different ways of storing and delivering messages. They serve different use cases depending on how you want messages to be processed.

A queue:

• Stores messages until they are consumed.
• Delivers messages to consumers (usually one at a time).
• Removes messages once they are acknowledged.

Streams are a newer feature designed for high-throughput and event streaming scenarios.

A stream:

• Stores messages as a continuous log (like an event history).
• Messages are not deleted after consumption.
• Consumers can read messages multiple times.

On navigating to Queues and Streams tab there won’t be any since we haven’t created a message. We will do it in just a moment.

ASP.NET Core Publisher Microservice

Lets start with creating a Publisher Microservice. In visual studio create a new project by selecting the template called ASP.NET Core Web App (Model-View-Controller). We named this project MTTutorialP, you can name it anything. This microservices acts as a Publisher that can interact with other Consumer microservices via RabbitMQ.

We first add an Order.cs class to the project which is for the orders made by customers. We gave the namespace MTTutorialC.Models for this class. We will use the same class with the same namespace on the Consumer also. This is because RabbitMQ treats messages based on it’s namespaces. if the received and outgoing message are of different namespace (signatures), RabbitMQ would not recognize the Consumer.

namespace MTTutorialC.Models
{
    public class Order
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Quantity { get; set; }
    }
}

Installing MassTransit Packages

MassTransit is a free, open-source “distributed application framework” for .NET. At its core, it acts as a service bus—a layer of abstraction that sits on top of message brokers (like RabbitMQ, Azure Service Bus, or Amazon SQS) to make building message-based, loosely coupled applications much easier. Think of it as an “Object-Relational Mapper” (ORM) but for messaging. Just as Entity Framework abstracts the complexities of SQL, MassTransit abstracts the complexities of message brokers. So install the following 2 MassTransit packages to the project from NuGet:

Install-Package MassTransit
Install-Package MassTransit.RabbitMQ

After adding the MassTransit packages, we will have to configure it to work as a Publisher. Navigate to the Program.cs and add the following code that registers MassTransit as a service.

builder.Services.AddMassTransit(x =>
{
    x.UsingRabbitMq();
});

Note that in the above case the MassTransit will use default RabbitMQ username and password which is “guest”. If the username and password are different then you can specify them using the below configurations.

builder.Services.AddMassTransit(x =>
{
    x.UsingRabbitMq((context, cfg) =>
    {
        cfg.Host("localhost", "/", h =>
        {
            h.Username("myusername");
            h.Password("mypassword");
        });
    });
});

Publisher: Send Message to RabbitMQ with MassTransit

Lets post an Order message to RabbitMQ with MassTransit. Open HomeController.cs file and inject ISendEndpointProvider object to the constructors. This object will be provided by the dependency injection.

We then use the ISendEndpointProvider to get the endpoint address and using it we send the order message to RabbitMQ. Check the below code.

public class HomeController : Controller
{
    private readonly ISendEndpointProvider sendEndpointProvider;

    public HomeController(ISendEndpointProvider sendEndpointProvider)
    {
        this.sendEndpointProvider = sendEndpointProvider;
    }
    
    public async Task<IActionResult> Index()
    {
        var endpoint = await sendEndpointProvider.GetSendEndpoint(new Uri("queue:OrderC"));

        await endpoint.Send(new Order {
            Id = 1,
            Name = "Football",
            Quantity = 10
        });

        return View();
    }
}

Notice the GetSendEndpoint method needs the RabbitMQ queue name which is given as queue:OrderC. Here “OrderC” is the name of the queue. Name of the queue can be anything.

The Order message containing the Order.cs class values of id=1, name=football and quantity=10 is send to RabbitMQ.

Lets test the working by running the project. The Index action of HomeController will execute automatically as it is the default route of the ASP.NET Core MVC project. Next, open RabbitMQ UI on browser and check the Connections and Channels where we will see new entry, this specifies that RabbitMQ has received the message.

The most important thing is the addition of a new exchange called “OrderC” which we can find on the Exchanges area. Check the below image.

Recall we gave the queue name “OrderC” in the URI of GetSendEndpoint() method.

Now go to Queues and Streams where we find a new entry. The message is waiting for a consumer to pick them up for processing. See the state of the message showing 0 for Ready, Unacked and Total which means message is waiting for a consumer. Check the below image:

Click on the message to see it details, we can see there are no consumers for the message. Check the below image.

In RabbitMQ, the terms Ready, Unacked, and Total describe the state of messages in a queue:

• Messages that are waiting in the queue
• Not yet delivered to any consumer
• Available to be consumed immediately

• Messages that have been delivered to a consumer
• But the consumer has not yet acknowledged (ACKed) them
• These are “in progress”
• If the consumer crashes or disconnects, RabbitMQ will requeue them

• The sum of Ready + Unacked
• Represents all messages currently in the queue

ASP.NET Core Consumer Microservice

Lets add a Consumer, so right click on the Solution and select add a new project. Select the same old template of ASP.NET Core Web App (Model-View-Controller), and name the project as “MTTutorialC”. Name is not important and you can choose your own name.

This .NET Microservice will be responsible for consuming the incoming messages from RabbitMQ. Do you remember the packages we installed earlier? Install the same one in this project too.

To this project add the Order.cs class that has the name namespace like the Order.cs defined in the publisher project. This is the requirement for RabbitMQ.

namespace MTTutorialC.Models
{
    public class Order
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public int Quantity { get; set; }
    }
}

Next, we configure the MassTransit in the program class as shown below.

builder.Services.AddMassTransit(x =>
{
    x.AddConsumer<OrderC>();

    x.UsingRabbitMq((context, cfg) =>
    {
        cfg.ConfigureEndpoints(context);
    });
});

In the above code we added the consumer – x.AddConsumer<OrderC>(). OrderC is the consumer class which will receive the message.

Next, we configured the Endpoints of RabbitMQ for MassTransit using the below code:

x.UsingRabbitMq((context, cfg) =>
{
    cfg.ConfigureEndpoints(context);
});

Consumer: Receive Message from RabbitMQ with MassTransit

To receive messages from RabbitMQ using MassTransit, we need to define a class that will be the consumer for the message. It has to inherit the IConsumer&ltT> where T is the type of message which is “Order” for our case. The code of this class called OrderC.cs is given below.

namespace MTTutorialC.Models
{
    public class OrderC : IConsumer<Order>
    {
        public async Task Consume(ConsumeContext<Order> context)
        {
            var jsonMessage = JsonConvert.SerializeObject(context.Message);
            Console.WriteLine($"OrderCreated message: {jsonMessage}");
        }
    }
}

The message received is serialized by the Json.NET library which we can install by the below command.

Install-Package Newtonsoft.Json

Testing the Microservices

Let’s test our Microservices now. We need both the Microservices running in order to send and receive the messages. To enable Multiple Starup Projects, Right click on the solution and set the action of each project to “Start”. See the below image.

Place a breakpoint on the line “var jsonMessage” in the consumer. Now press the Run button on Visual Studio which will start both the projects.

The breakpoint will hit and we can see the message is received by the consumer. Check the below image.

Go to Queues and Streams on the RabbitMQ UI where we will find a new queue is formed. Check the below image.

Click the Queue to see it’s details check the consumer binding now present.

Publisher sends message Consumer unavailable

The consumer can be offline due to several reasons like server issues. Even if the consumer is offline, the publisher can still send messages to the RabbitMQ queue. Once the consumer comes back online, it can process any pending messages. That’s essentially the core idea behind message brokering—let’s take a closer look.

Change the startup to run only the Publisher project (and not Consumer). This mimics the scenario where the consumer if offline. If we run the publisher project the message goes to rabbitmq queue.

Now change the setup to run only the Consumer project. Put a breakpoint on the OrderC.cs class Consume method. Run the project in Visual Studio, we will see breakpoint hits telling the message is received from RabbitMQ.

In this article, we explored message brokers, RabbitMQ, its advantages, and how to integrate it with ASP.NET Core using MassTransit. We also built a small prototype application to demonstrate sending data through a RabbitMQ server. You can find the complete source code for this implementation here.

Feel free to share your questions and suggestions in the comments below. If you found this article helpful or learned something new, consider sharing it with your developer community. Happy coding!

The post How to use RabbitMQ with MassTransit for ASP.NET Core Microservices Communication appeared first on YogiHosting.

In this tutorial we will be building a simple real-world implementation to help understand jQuery DataTables to it’s fullest. The whole working is given by the below gif image. It will have paginations, to searching, to sorting and deleting.

Key Features of jQuery DataTables:

• Pagination – Automatically splits large tables into number based pages.
• Search / Filtering – Users can quickly search inside the table.
• Column Sorting – Click column headers to sort them in ascending/descending way.
• Responsive Tables – Works on mobile and desktop, responsiveness through Bootstrap.
• AJAX Data Loading – Load data dynamically from APIs or servers.
• Export Options – Export to CSV, Excel, PDF, etc.
• Custom Styling – Works with frameworks like Bootstrap.

Client-side Pagination vs Server-side Pagination

Pagination in a grid means splitting a large set of data into smaller pages so the user only sees a limited number of rows at a time instead of the entire dataset. Suppose a grid contains 1,000 records then instead of showing all 1,000 rows at once, pagination shows something like:

• Page 1: rows 1–10
• Page 2: rows 11–20
• Page 3: rows 21–30
• … and so on.

Advantage of Pagination are:

• Better performance – Loading fewer records at once makes the page faster.
• Better user experience – Easier to read smaller sets of data.
• Reduced server load – Especially when data comes from a database.
• Cleaner UI – Avoids very long scrolling tables.

Client-side Processing means all the records are loaded into the browser first, and the pagination (page switching) is handled using jQuery on the client (browser), instead of requesting new data from the server each time.

Server-side Processing means the server sends only a small portion of records (i.e. records for a particular page number) to the browser instead of sending the entire records at once. When the user moves to another page, the browser requests the records for that page from the server.

jQuery DataTables offers both Client and Server Side Processing. Client Side Processing works best when there are less than 1000 records to show on jQuery DataTables. If you have more than 1000 records then it is important to use Server Side Processing where only the records for the particular page are fetched from the server. With Server Side Processing you are drastically improving the load time (as the JQuery Datatable is loading just the records of the particular page and not each and every record), reducing the CPU and bandwidth usage.

ASP.NET Core Database driven app

In our ASP.NET Core app, we will read Employee records from the database using Entity Framework Core. Then these records are display in jQuery DataTables. First, add Employee.cs in the Models folder.

public class Employee
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Gender { get; set; }
    public string Email { get; set; }
    public string Telephone { get; set; }
    public DateTime DateOfBirth { get; set; }
    public string Designation { get; set; }
}

We add the following packages to set up Entity Framework Core.

Install-Package Microsoft.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.Tools
Install-Package Microsoft.EntityFrameworkCore.SqlServer
Install-Package Microsoft.EntityFrameworkCore.Design

Next, we add DbContext file called CompanyContext.cs inside the Models folder.

public class CompanyContext : DbContext
{
    public CompanyContext(DbContextOptions<CompanyContext> options) : base(options)
    {
    }

    public DbSet<Employee> Employee { get; set; }
}

After this add the connection string in the appsettings.json as given below.

"ConnectionStrings": {
  "DefaultConnection": "Data Source=(localdb)\\MSSQLLocalDB;Initial Catalog=Company;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=true;ApplicationIntent=ReadWrite;MultiSubnetFailover=False"
}

With everything set, we perform the Migrations. Open up your package manager console and use the following commands.

add-migration Migration1
update-database

With the database ready, we add 1000 dummy records to the database. There are many free tools available to generate dummy data like – generatedata, mockaroo, etc. We generated 1000 records for Employee table in SQL Insert script and executed the script directly in the database.

Good news! We will be providing 1000 dummy records SQL Insert script for you to use. Check the GitHub repository.

Create HTML Table for Employee Records

In order to implement JQuery Datatable, lets define the structure of our HTML Table in a Razor View File. In the Views Folder, edit up the Index.cshtml to include the HTML table as shown below:

@{
    ViewData["Title"] = "Home Page";
}

<link href="//cdn.datatables.net/2.3.7/css/dataTables.dataTables.min.css" rel="stylesheet" />

<div class="text-center">
    <h1 class="display-4">Welcome</h1>
    <p>Learn about <a href="https://learn.microsoft.com/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
</div>

<div class="container">
    <table id="employeeDataTable" class="table table-striped table-bordere">
        <thead>
            <tr>
                <th>ID</th>
                <th>First Name</th>
                <th>Last Name</th>
                <th>Gender</th>
                <th>Email</th>
                <th>Telephone</th>
                <th>DateOfBirth</th>
                <th>Designation</th>
            </tr>
        </thead>
    </table>
</div>

@section Scripts
{
    <script src="//cdn.datatables.net/2.3.7/js/dataTables.min.js"></script>

    <script>
        $(document).ready(function () {
            $('#employeeDataTable').dataTable({
            
            });
        });
    </script>
}

This will render jQuery DataTables as shown by the image below.

Although, we get the message “No data available in table” which is obvious since we have not applied the data to the DataTables till now. This we will do in just a moment.

Let’s understand the above code.

1. We created an HTML table to display Employee records.
2. On the top we provide the link to jQuery DataTables css.
3. On the bottom inside the script tag we provided the like of jQuery DataTables JavaScript file.
4. Both the CSS and JavaScript will be downloaded from CDN.
5. We invoke the DataTable() method by using the ID of the employee table which is employeeDataTable. This is how to initialize the datatable.

The below line initialize the jQuery DataTables.

<script>
    $(document).ready(function () {
        $('#employeeDataTable').dataTable({
            
        });
    });
</script>

How to use jQuery DataTables

Lets understand how to use DataTables by configuring it. Update the jQuery DataTables as shown below.

<script>
    $(document).ready(function () {
        $('#employeeDataTable').dataTable({
            processing: true,
            serverSide: true,
            "filter": true,
            "ajax": {
                "url": "/api/Employee/GetEmployees",
                "type": "POST",
                "datatype": "json"
            },
            "columns": [
                { "data": "id" },
                { "data": "firstName" },
                { "data": "lastName" },
                { "data": "gender" },
                { "data": "email" },
                { "data": "telephone" },
                { "data": "dateOfBirth"},
                { "data": "designation" }
            ]
        });
    });
</script>

In the above code we applied parameters to configure our jQuery DataTables. These parameters are:

• processing – A boolean property that is used to control the visibility of the “processing” indicator message.
• serverSide – This property enables server-side processing.
• filter – enables/disables the search bar.
• ajax – used to fetch the data from external sources using JavaScript AJAX. We will create Web API though which this data will be fetched.
• columns – columns declared in the DataTables.

See the “columns” options given as data: columnname. Let understand it deeper. When naming variables, it’s important to follow camelCase conventions. For example, firstName is correct, while FirstName is not. It might seem a bit unusual, but that’s how JavaScript works—so be sure to stick to camelCase when writing your scripts.

Also, keep in mind that the API returns a list of records under the key ‘data’. That’s why we reference fields as data.id, data.firstName, and so on when defining column values.

The ajax url is given as “url”: “/api/Employee/GetEmployees”. It is the url of the Web API that will return the employee records. Let’s create the Web API.

Web API to return data for jQuery DataTables

Add a new API Controller to the Controllers folder and name it EmployeeController.cs. We also need to install the package required for data sorting. So run the below install command on NuGet.

Install-Package System.Linq.Dynamic.Core

After installing the package, you can proceed with adding the necessary code to the EmployeeController.cs.

using jQueryDataTables.Models;
using Microsoft.AspNetCore.Mvc;
using System.Linq.Dynamic.Core;
using System.Text.Json;

namespace jQueryDataTables.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class EmployeeController : ControllerBase
    {
        private CompanyContext context;
        public EmployeeController(CompanyContext cc)
        {
            context = cc;
        }

        [HttpPost("GetEmployees")]
        public IActionResult GetEmployees()
        {
            var draw = Request.Form["draw"].FirstOrDefault();
            var start = Request.Form["start"].FirstOrDefault();
            var length = Request.Form["length"].FirstOrDefault();
            
            var colIndex = Request.Form["order[0][column]"];
            string sortColumn = Request.Form["columns[" + colIndex + "][data]"].FirstOrDefault();

            var sortColumnDirection = Request.Form["order[0][dir]"].FirstOrDefault();
            var searchValue = Request.Form["search[value]"].FirstOrDefault();
            int pageSize = length != null ? Convert.ToInt32(length) : 0;
            int skip = start != null ? Convert.ToInt32(start) : 0;
            int recordsTotal = 0;
            var employeeData = (from t in context.Employee select t);

            if (!(string.IsNullOrEmpty(sortColumn) && string.IsNullOrEmpty(sortColumnDirection)))
            {
                employeeData = employeeData.OrderBy($"{sortColumn} {sortColumnDirection}");
            }
            if (!string.IsNullOrEmpty(searchValue))
            {
                employeeData = employeeData.Where(m => m.FirstName.Contains(searchValue)
                                            || m.LastName.Contains(searchValue)
                                            || m.Email.Contains(searchValue));
            }
            recordsTotal = employeeData.Count();
            var data = employeeData.Skip(skip).Take(pageSize).ToList();
            var jsonData = new { draw = draw, recordsFiltered = recordsTotal, recordsTotal = recordsTotal, data = data };

            string jsonString = JsonSerializer.Serialize(jsonData);

            return Ok(jsonData);
        }
    }
}

The work of the APIController is to fetch the employee records from the database in page by page manner. It uses Entity Framework Core to do this task.

First, we get the values of draw, start & length and order[0][column] from Request.Form. These are used for create pagination in DataTables. We can see page size in the Dropdown of DataTables that says, ‘Showing n entries’ where n being the page size.

var draw = Request.Form["draw"].FirstOrDefault();
var start = Request.Form["start"].FirstOrDefault();
var length = Request.Form["length"].FirstOrDefault();

The 3 variables colIndex, sortColumn, sortColumnDirection get the values of necessary columns for performing sorting in DataTables. These are using Request.Form method to get these values from the html of the page.

var colIndex = Request.Form["order[0][column]"];
string sortColumn = Request.Form["columns[" + colIndex + "][data]"].FirstOrDefault();
var sortColumnDirection = Request.Form["order[0][dir]"].FirstOrDefault();

The searchValue variable contains the value to search in the DataTables.

Next, we added the code for fetching and showing the records of the current page.

int pageSize = length != null ? Convert.ToInt32(length) : 0;
int skip = start != null ? Convert.ToInt32(start) : 0;
int recordsTotal = 0;

With LINQ Skip and Take method we get these records and convert them to json. This json is send to jQuery DataTables where the records are displayed.

recordsTotal = employeeData.Count();
var data = employeeData.Skip(skip).Take(pageSize).ToList();
var jsonData = new { draw = draw, recordsFiltered = recordsTotal, recordsTotal = recordsTotal, data = data };

string jsonString = JsonSerializer.Serialize(jsonData);

Also check the codes that performs the sorting and searching (filtering) of records. Note that searching is performed on FirstName, LastName and Email fields.

if (!(string.IsNullOrEmpty(sortColumn) && string.IsNullOrEmpty(sortColumnDirection)))
{
    employeeData = employeeData.OrderBy($"{sortColumn} {sortColumnDirection}");
}

if (!string.IsNullOrEmpty(searchValue))
{
    employeeData = employeeData.Where(m => m.FirstName.Contains(searchValue)
                                || m.LastName.Contains(searchValue)
                                || m.Email.Contains(searchValue));
}

Well it’s time to see the working. Run the app and you can see the records displayed by the jQuery DataTables. You can see the page size dropdown on the top left, search box on the top right. At the bottom there are the page numbers for navigating between the records. Also see that clicking the column names will sort the records in ascending and descending manner.

In the below image we are showing the search/filtering feature in jQuery DataTables.

Delete a row from jQuery DataTables

Lets understand how to add delete record feature on jQuery DataTables. Once this feature is complete we get a delete button against every row of records, click on a delete button will delete the corresponding row of data. See the below image.

For this we need to add a new column for the “Delete” button that will show against each row of records. We will use columns.render option in the table initialization. This option accepts a function or a built-in renderer to transform the cell’s underlying data.

See the below code where we gave a delete button against the rows using render option.

"columns": [
    { "data": "id" },
    { "data": "firstName" },
    { "data": "lastName" },
    { "data": "gender" },
    { "data": "email" },
    { "data": "telephone" },
    { "data": "dateOfBirth"},
    { "data": "designation" },
    {
      "render": function (data, type, full, meta) {
        // 'full' contains the data for the entire row
        return '<button class="btn btn-danger" data-id="' + full.id + '">Delete</button>'; }
    }
]

<p>Next, we add click event to this button using the below JS. The JS calls a method named "deleteRecord".</p>

$('#employeeDataTable tbody').on('click', '.btn-danger', function () {
        // Get the record ID from the button's data attribute
        var recordId = $(this).data('id');

        // Get the specific table row (tr) that was clicked
        var row = $(this).closest('tr');

        // Confirm the deletion with the user (optional)
        if (confirm('Are you sure you want to delete this record?')) {
            deleteRecord(recordId, row);
        }
    });
});

We next add the function called “deleteRecord”. This function make use of the jQuery AJAX method to call another method of our Web API which will actually be deleting the records from the database. Check the below code.

function deleteRecord(id, row) {
    $.ajax({
        url: "/api/Employee/" + id, 
        type: "DELETE", 
        dataType: "json",
        success: function (response) {
            if (response) {
                var dt = new DataTable('#employeeDataTable');
                // Remove the row from the DataTables instance
                // row().remove() deletes the data and node from the browser memory
                // draw(false) updates the display without resetting the pagination
                dt.row(row).remove().draw(false);
                alert('Record deleted successfully!');
            } 
            else {
                alert('Error deleting record on the server.');
            }
        },
            error: function (xhr, status, error) {
            alert('An error occurred during the AJAX request: ' + error);
        }
    });
}

In the above code we are providing the row id in the url as url: “/api/Employee/” + id. Also note the DataTables method – row().remove() is used to deletes the data and node from the browser memory and draw(false) updates the display without resetting the pagination.

Finally we add the delete method to our Web Api which does the record deletion and returns a bool value of true (in json) once the deletion is successful.

[HttpDelete("{id}")]
public IActionResult Delete(int id)
{
    bool status = false;
    var entityToDelete = context.Employee.Where(e => e.Id == id).FirstOrDefault();
    if (entityToDelete != null)
    {
        context.Employee.Remove(entityToDelete);
        context.SaveChanges();
        status = true;
    }
    return new JsonResult(status);
}

Let’s test the deletion of record. We click the delete button against any row which we want to delete. We will get a successful alert message once the deletion is completed.

In this article, we explored everything you need to know about working with jQuery DataTables in ASP.NET Core using server-side processing. We covered the syntax, required files, and overall integration, and built a clean data table featuring paging, sorting, searching, and efficient server-side handling. You can find the complete source code for this implementation in GitHub repository (link given at the top).

I hope this article helped you gain a solid understanding of jQuery DataTables in ASP.NET Core. If you have any feedback or suggestions, feel free to share them in the comments section below. Don’t forget to share this article with your developer community. Thanks, and happy coding!

The post jQuery DataTables in ASP.NET Core with Server Side Processing appeared first on YogiHosting.

Install and Configure Prometheus

Download Prometheus for your OS from https://prometheus.io/download/ and extract the contents of the download. I am using Window 11 OS so I have downloaded the windows version and extracted the zip file contents to a folder in my PC. Inside this folder their are 2 important files prometheus.exe which starts prometheus and prometheus.yml which contains the configurations.

Open the prometheus.yml file to find the below lines. It specifies that Prometheus will run from http://localhost:9090 url in the browser.

static_configs:
  - targets: ["localhost:9090"]
   # The label name is added as a label `label_name=<label_value>` to any timeseries scraped from this config.
    labels:
      app: "prometheus"

Next, add the following code lines at the end of this file.

- job_name: 'MyASPNETApp'
  scrape_interval: 5s # Poll every 5 seconds
  static_configs:
    - targets: ["localhost:5284"]  ## Enter the HTTP port number of .NET app

In the above lines job_name is given MyASPNETApp which can be any name of your choice. Then for scrape_interval give 5s, which is the number of seconds at which Prometheus server scrapes metrics from the app. And finally for the targets specify the http url of the app which in my case is localhost:5284. Note that you have to enter HTTP url not HTTPS one. You will find the app’s http url inside launchsettings.json file.

Save this file and now double click on the prometheus.exe file to start Prometheus. A console window will open showing logs of Prometheus, this specifies that Prometheus is now running. Next, open url – http://localhost:9090 on the browser which opens Prometheus, see below screenshot.

We are going to integrate Prometheus in our app.

Integrate Prometheus in ASP.NET Core app

First, reference the OpenTelemetry packages. Use the NuGet Package Manager or command line to add the following NuGet packages.

dotnet add package OpenTelemetry.Exporter.Console
dotnet add package OpenTelemetry.Exporter.OpenTelemetryProtocol
dotnet add package OpenTelemetry.Exporter.Prometheus.AspNetCore --prerelease
dotnet add package OpenTelemetry.Extensions.Hosting
dotnet add package OpenTelemetry.Instrumentation.AspNetCore
dotnet add package OpenTelemetry.Instrumentation.Http

Next, open Program.cs class and configure OpenTelemetry with the Prometheus provider.

var otel = builder.Services.AddOpenTelemetry();

// Configure OpenTelemetry Resources with the application name
otel.ConfigureResource(resource => resource
    .AddService(serviceName: builder.Environment.ApplicationName));

otel.WithMetrics(metrics => metrics
    .AddAspNetCoreInstrumentation()
    .AddMeter("Microsoft.AspNetCore.Hosting")
    .AddMeter("Microsoft.AspNetCore.Server.Kestrel")
    .AddMeter("System.Net.Http")
    .AddMeter("System.Net.NameResolution")
    .AddPrometheusExporter());

Through WithMetrics() method we are adding Metrics for ASP.NET Core. Metrics are numerical measurements about your application’s behavior and performance. They help you monitor how the app is running in production or during testing. Metrics are usually collected continuously and sent to monitoring tools like Prometheus, Grafana, or Azure Monitor.

Metrics provide quantitative data about your application such as:

• Number of requests
• Response time
• Error rates
• CPU or memory usage
• Database query duration

They help answer questions like:

• Is the API slow?
• How many users are hitting the server?
• Are errors increasing?

Finally, add the OpenTelemetry Prometheus Scraping Endpoint middleware. This means the app metrics are going to Prometheus where we can see their details.

// Configure the Prometheus scraping endpoint
app.MapPrometheusScrapingEndpoint();

Run the app in visual studio and visit the uri – “/metrics” which in our case is https://localhost:7285/metrics. Here all the metrics are shown, see the below image.

Next, on Prometheus go to Status > Target health where you will see the app’s metrics url listed. This means Prometheus is receiving the apps metrics input correctly. See the below image.

Adding Custom Metrics and export to Prometheus

Lets add a Custom Metrics to the app. Start by adding a new class called AppCustomMeter.cs whose code is given below. The class uses IMeterFactory to create a meter instance.

public class AppCustomMeter
{
    public static string name = "CustomMeter";

    private readonly Counter<int> productCounter;
    
    public AppCustomMeter(IMeterFactory meterFactory)
    {
        var meter = meterFactory.Create(name);
        productCounter = meter.CreateCounter<int>("Product.Sold");
    }
    public void ProductSold(string productName, int quantity)
    {
        productCounter.Add(quantity, new KeyValuePair<string, object?>("Product.Name", productName));
    }
}

Now on Program.cs register this custom metrics as a singleton.

builder.Services.AddSingleton<AppCustomMeter>();

Also add it to the OpenTelemetryBuilder with AddMeter method as shown in highlighted code below.

otel.WithMetrics(metrics => metrics
    .AddAspNetCoreInstrumentation()
    .AddMeter(AppCustomMeter.name)
    .AddMeter("Microsoft.AspNetCore.Hosting")
    .AddMeter("Microsoft.AspNetCore.Server.Kestrel")
    .AddMeter("System.Net.Http")
    .AddMeter("System.Net.NameResolution")
    .AddPrometheusExporter());

Now we can test the metrics in work. On the HomeController file, provide the custom metrics class object through DI.

private AppCustomMeter appCustomMeter;

public HomeController(AppCustomMeter appCustomMeter)
{
    this.appCustomMeter = appCustomMeter;
}

Then call the ProductSold method of the metrics to add 3 football quantity.

public IActionResult Index()
{
    appCustomMeter.ProductSold("Football", 3);
    
    return View();
}

Rerun the app, and check the metrics on Prometheus. Click the 3 dots given on the search text box. This will open a menu, select “Explore metrics”.

A Dialog opens where you will see “Product_Sold_total”, click the lens icon to explore it.

The “Product_Sold_total” metrics details opens up. Here click the Insert button which will add this metrics to the search text box of the previous dialog.

In this page, select the Graph and click the Execute button to see the graph. You can see the graph of the football product sold over time. Check the below image where we have explained this thing.

There are large number of metrics to explore. Example put http_ in the search text box to see the available metrics.

In the same way put kestrel in the search text box to see the kestrel related metrics.

Integrate Grafana in ASP.NET Core app

Download Grafana from https://grafana.com/oss/grafana/ and install it to your pc. On windows you get an installer to install Grafana. After installation open the grafana url – http://localhost:3000. You’ll need to log in; the default username and password are both “admin”.

Now, go to ‘Add new connection’ and search Prometheus for Data Sources then click Prometheus.

On the prometheus page click the “Add new data source” button. This will add prometheus to grafana.

Next, you will be taken to the prometheus configurations page. Here add prometheus server url which is http://localhost:9090. Then click “Save & test” button. This will show successful message along with a link “building a dashboard”. Click this link to start building the dashboard. Check the below image screenshot.

On the next page, click “Add visualization” button.

Next, click on “prometheus” for data source.

This will take you to Grafana Dashboard where you can select the metrics – “”Product_Sold_total” and click the “Run queries” button to see the graph of this metrics. Check the below image where we have shown this.

We have successfully integrated Grafana in ASP.NET Core app. We can design sophisticated dashboards that will track any number of metrics. Each metric in .NET can have dimensions, which are key-value pairs that can be used to partition the data.

In this tutorial we learned how to integrate Prometheus and Grafana in ASP.NET Core. We also learned how to create custom metrics and view it’s details in prometheus. At the end we also learned to create dashboards in Grafana where metrics are viewed in graphs. We hope you liked this tutorial, if any question ask them through the comments section below.

The post How to use Prometheus and Grafana in ASP.NET Core appeared first on YogiHosting.

Whether you are handling batch data imports, real-time telemetry, or large-scale synchronization, Entity Framework Extensions library bridges the gap between the productivity of an ORM and the raw speed of specialized data loading tools. Thus offers a “need for speed” approach, that can reduce execution times by up to 95%, all while maintaining seamless integration with your existing DbContext and entity configurations.

In this tutorial we will be implementing Entity Framework Extensions library features in our ASP.NET Core app to create popular features on bulk operations.

Integration of Entity Framework Extensions

In the ASP.NET Core app, open NuGet package manager and install the package Z.EntityFramework.Extensions.EFCore. Since Entity Framework Extensions works with EF Core therefore the app should also have Microsoft.EntityFrameworkCore.SqlServer package installed.

Below I have shown the screenshot of this library from NuGet Package Manager.

Bulk Inserting a large CSV file on SQL Server Database with Entity Framework Extensions

Lets build the bulk Inserting of records to a SQL Server Database with Entity Framework Extensions library. I will use a CSV file, containing 50,000 + records of the World Bank economic survey, for this bulk inserting work. You can find this CSV file on the GitHub repository along with the app.

Note that for working with CSV files, I will be using CsvHelper library, that can be installed from NuGet.

On the ASP.NET Core app, add the entity class called Survey.cs. This class maps the survey records on the CSV file.

public class Survey
{
    public string Year { get; set; }
    public string Industry_aggregation_NZSIOC { get; set; }
    public string Industry_code_NZSIOC { get; set; }
    public string Industry_name_NZSIOC { get; set; }
    public string Units { get; set; }
    public string Variable_code { get; set; }
    public string Value { get; set; }
    public string Variable_name { get; set; }
    public string Variable_category { get; set; }
    public string Industry_code_ANZSIC06 { get; set; }
}

Next, I add the razor view file called ImportCsv.cshtml file which contains a file upload control for uploading the csv file.

@{
    ViewData["Title"] = "Upload CSV";
}

<h1 class="bg-info text-white">Upload CSV</h1>

<h2>@ViewData["Message"]</h2>

<form method="post" enctype="multipart/form-data">
    <div class="form-group">
        <label for="Poster"></label>
        <input type="file" id="csvfile" name="csvfile" class="form-control" />
    </div>
    <button type="submit" class="btn btn-primary">Create</button>
</form>

The Controller code which performs the bulk data inserts in the database is given below.

public class AdminController : Controller
{
    private BulkContext context;
    private IWebHostEnvironment hostingEnvironment;
    public AdminController(BulkContext c, IWebHostEnvironment environment)
    {
        context = c;
        hostingEnvironment = environment;
    }

    public IActionResult ImportCsv()
    {
        return View();
    }

    [HttpPost]
    [ActionName("ImportCsv")]
    public async Task<IActionResult> ImportCsv_Post(IFormFile csvfile)
    {
        // By CsvReader Package
        string path = Path.Combine(hostingEnvironment.WebRootPath, "CSV/" + csvfile.FileName);
        using (var stream = new FileStream(path, FileMode.Create))
        {
            await csvfile.CopyToAsync(stream);
        }

        var config = new CsvConfiguration(CultureInfo.InvariantCulture)
        {
            PrepareHeaderForMatch = args => args.Header.ToLower(),
            Delimiter = ",",
            MissingFieldFound = null,
            BadDataFound=null
        };
        using (var reader = new StreamReader(path))
        {
            using (var csv = new CsvReader(reader, config))
            {
                var records = csv.GetRecords<Survey>();
                context.BulkInsert(records, options => options.InsertKeepIdentity = true);

            }
        }
        ViewData["Message"] = "Import Successful";
        return View();
    }

}

Explanation – Here CsvReader library is used to read the csv file which the user uploads. After preforming some initial configurations, the csv records are read in a Survey class object by the below code:

var records = csv.GetRecords<Survey>();

Next, all the records are bulk insert with Entity Framework Extensions. Just a single line of code to do this job.

context.BulkInsert(records, options => options.InsertKeepIdentity = true);

I have used Stopwatch class to measure the time it takes to complete this operation. Note that there are massive 50,000 + records to be inserted. Entity Framework Extensions completed this in 2183 milliseconds. This is indeed quite impressive. Check the below screenshot.

Need More Speed ? Use BulkInsertOptimized method. It is 25% more fast. See below code line.

context.BulkInsertOptimized(records, options => options.InsertKeepIdentity = true);

The Key difference between them are:

• BulkInsert: AutoMapOutputDirection = true by default. It returns values like identity keys but can generate slightly less optimized SQL.
• BulkInsertOptimized: AutoMapOutputDirection = false by default. It skips return values for maximum speed, unless you explicitly ask for them.

By the way this whole code is there on my GitHub repository which you can copy and use it freely.

Reading CSV files by old OleDbConnection manner

We can also read CSV files by old OleDbConnection class without using CsvHelper. The below code does this work.

Note that you have to install the package System.Data.OleDb from NuGet.

[HttpPost]
public async Task<IActionResult> ImportCsv_Old(IFormFile csvfile)
{
    // By old OleDbConnection way

    string path = Path.Combine(hostingEnvironment.WebRootPath, "CSV/" + csvfile.FileName);
    using (var stream = new FileStream(path, FileMode.Create))
    {
        await csvfile.CopyToAsync(stream);
    }

    string folderPath = Path.Combine(hostingEnvironment.WebRootPath, "CSV"); // The Data Source is the folder, not the file
    string connectionString = $@"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={folderPath};Extended Properties=""text;HDR=YES;FMT=Delimited;IMEX=1;MaxScanRows=0""";

    using (var conn = new OleDbConnection(connectionString))
    {
        conn.Open();
        var query = $"SELECT * FROM [{csvfile.FileName}]"; // The file name is used in the query
        using (var adapter = new OleDbDataAdapter(query, conn))
        {
            var dataTable = new DataTable();
            adapter.Fill(dataTable);

            List<Survey> records = dataTable.AsEnumerable().Select(row => new Survey
            {
                Year = row.Field<string>("year"),// Use .Field<T>() for type safety and null handling
                Industry_aggregation_NZSIOC = row.Field<string>("vote_average"),
                Industry_code_NZSIOC = row.Field<string>("industry_code_NZSIOC"),
                // other fiels add heere
            }).ToList();

            context.BulkInsert(records, options => options.InsertKeepIdentity = true);
        }
    }

    return View();
}

Copying large DB data from one Table to another Table with Entity Framework Extensions

Entity Framework Extensions high speed is useful in making backups of the database tables. This can come handy in situations like copying a large DB table to another table.

Here I have a massive database containing 200k + movies records in my dabase table called BulkMovies. I will copy all its records to a new table called BulkMoviesCopy.

To do this I will have to add 2 classes for the movie object as shown below. Since we are making a copy therefore these classes fields are all same.

public class BulkMovies
{
    public int? Id { get; set; }
    public string Title { get; set; }
    public double? Vote_Average { get; set; }
    public int? Vote_Count { get; set; }
    public string Status { get; set; }
    public DateTime? Release_Date { get; set; }
    public long? Revenue { get; set; }
    public int? Runtime { get; set; }
    public string Adult { get; set; }
    public int? Budget { get; set; }
    public string Homepage { get; set; }
    public string Overview { get; set; }
    public string Tagline { get; set; }
    public string Genres { get; set; }
    public string Production_Companies { get; set; }
    public string Production_Countries { get; set; }
    public string Spoken_Languages { get; set; }
    public string Keywords { get; set; }
}

public class BulkMoviesCopy
{
    public int? Id { get; set; }
    public string Title { get; set; }
    public double? Vote_Average { get; set; }
    public int? Vote_Count { get; set; }
    public string Status { get; set; }
    public DateTime? Release_Date { get; set; }
    public long? Revenue { get; set; }
    public int? Runtime { get; set; }
    public string Adult { get; set; }
    public int? Budget { get; set; }
    public string Homepage { get; set; }
    public string Overview { get; set; }
    public string Tagline { get; set; }
    public string Genres { get; set; }
    public string Production_Companies { get; set; }
    public string Production_Countries { get; set; }
    public string Spoken_Languages { get; set; }
    public string Keywords { get; set; }
} 

Next, on a post action method, which is shown below, I have used BulkInsert method to perform the copying task.

[HttpPost]
[ActionName("BulkCopy")]
public IActionResult BulkCopy_Post()
{
    List<BulkMovies> bm = context.BulkMovies.AsQueryable().ToList();

    List<BulkMoviesCopy> bmc = bm.Select(t => new BulkMoviesCopy
    {
        Id = t.Id,
        Title = t.Title,
        Vote_Average = t.Vote_Average,
        Vote_Count = t.Vote_Count,
        Status = t.Status,
        Release_Date = t.Release_Date,
        Revenue = t.Revenue,
        Runtime = t.Runtime,
        Adult = t.Adult,
        Budget = t.Budget,
        Homepage = t.Homepage,
        Overview = t.Overview,
        Tagline = t.Tagline,
        Genres = t.Genres,
        Production_Companies = t.Production_Companies,
        Spoken_Languages = t.Spoken_Languages,
        Keywords = t.Keywords
    }).ToList();

    var clock = new Stopwatch();
    clock.Start();

    context.BulkInsert(bmc, options => options.InsertKeepIdentity = true);

    clock.Stop();
    var time = clock.ElapsedMilliseconds;

    return View();
}

It should be noted the BulkMoviesCopy object is mapped to the movies data contained by BulkMovies object called “bm” using the LINQ Select method as shown below.

List<BulkMovies> bm = context.BulkMovies.AsQueryable().ToList();
List<BulkMoviesCopy> bmc = bm.Select(t => new BulkMoviesCopy
{
    Id = t.Id,
    Title = t.Title,
    // include the fields that need to be copied
}).ToList();

Then with the BulkInsert method the full data is copied to the BulkMoviesCopy table by the below code line.

context.BulkInsert(bmc, options => options.InsertKeepIdentity = true);

Below is the result. It took just 9156 milliseconds to perform this job. Considering the records are massive and this little time to complete the job is indeed impressive.

Bulk Updates and Deletion

In Entity Framework Core we have Add and Update method to perform records Inserts and Updates. In Entity Framework Extensions there is a BulkMerge method which does both the work of records addition and records modification.

It matches the primary key or the composite key of the entity and then automatically decides which record needs to be inserted and which needs to be updated. This decision is made based on:

• If the DB table already has the row matching the record key (primary or composite) then this row is updated.
• If the DB table does not have any row matching the record’s key then this row is inserted to the table.

This certainly reduces the number of code lines if we have to perform multiple tasks like Inserts and Updates on the same method.

Now we are going to implement BulkMerge method in order to perform bulk update of the records.

Add Employee.cs class to the app which is given below:

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Designation { get; set; }
    public string Address { get; set; }
    public int Salary { get; set; }
}

Next, add an action method of HTTP POST type since we will be calling the codes on the button click. This action method is given below.

[HttpPost]
public async Task<IActionResult> BulkMerge_Post()
{
    List<Employee> emp = context.Employee.AsQueryable().ToList();

    List<Employee> updateEmployee = emp.Select(t => new Employee
    {
        Id = t.Id,
        Name = t.Name,
        Designation = t.Designation,
        Address = t.Address,
        Salary = t.Salary + 1000,
    }).ToList();

    context.BulkMerge(updateEmployee);

    return View();
}

The code above is increasing the salary of every employee by $1000. It is adding the 1000 to the current salary by – Salary = t.Salary + 1000 and then calling the BulkMerge method to perform this update.

In the same way we can perform the bulk inserts by modified code which is given below. This code inserts the Employees since their Id field is not provided.

List<Employee> insertEmployee = new List<Employee> {
    new Employee{Name="N1", Designation="D1", Address="A1", Salary=1000},
    new Employee{Name="N2", Designation="D2", Address="A2", Salary=2000},
    new Employee{Name="N3", Designation="D3", Address="A3", Salary=3000}
};

context.BulkMerge(insertEmployee);

Mostly in real work scenario you will come acrosss a situation where an excel / CSV file containing the updated data is provided to you. And you as a developer will have to update the database table with this new data on the file. In this situation make sure the key value (which here is Id) given on the excel / csv should match for the records which have to be updated while the key should be empty for the records that needs to be inserted.

See the below code which does exactly this thing.

[HttpPost]
public async Task<IActionResult> BulkMerge_Post()
{
    // read the excel/csv file code omitted for brevity

    List<BulkMoviesCopy> bmc = dataTable.AsEnumerable().Select(row => new    BulkMoviesCopy
{
    Id = row.Field<int>("id"), // Use .Field<T>() for type safety and null handling
    Name = row.Field<string>("name"),
    Designation = row.Field<string>("Designation"),
    Address = row.Field<string>("Address"),
    Salary = row.Field<int>("Salary"),
}).ToList();

    context.BulkMerge(updateEmployee);

    return View();
}

The excel file can contain tens of thousands of records and Entity Frameowork Extensions will complete this in a matter of seconds.

The bulk delete feature is provided through BulkDelete method which deletes large number of records in a fraction of seconds. Here also you can read the records that needs to be deleted from an excel or csv file and call this method as shown below.

context.BulkDelete(deleteEmployee);

The benefits of BulkDelete method:

1. Many ways to delete: custom keys, delete related entities and apply any conditions.
2. Super fast.
3. No need to load entities. No change tracking.

To wrap things up, Entity Framework Extensions serve as the “turbocharger” for the standard EF Core engine. While Microsoft has made great strides in optimizing EF Core, developers often hit a performance wall when dealing with large datasets or complex batch operations.

Here is a summary of why they remain a staple in the .NET ecosystem:

The Performance Edge:

The core value proposition is speed. By bypassing the traditional “one-at-a-row” processing model and utilizing efficient database-level commands, extensions can turn operations that take minutes into tasks that take seconds.

Key Takeaways:

Scalability: They are essential for enterprise-level applications where data growth is inevitable.

Developer Productivity: You get to keep the clean, LINQ-based syntax you love while gaining the performance of raw SQL.

Resource Efficiency: By reducing the number of round-trips to the database, you lower CPU and memory overhead on both the application server and the database.

Final Verdict:

Entity Framework Extensions are not a replacement for EF Core, but rather a necessary evolution for performance-critical applications. If your project involves data migrations, nightly syncs, or massive user-generated content, the investment in this library usually pays for itself in saved execution time and reduced infrastructure costs.

The post The Entity Framework Extensions: Performance-Focused (Need for Speed) when working with large Datasets appeared first on YogiHosting.