Cheap Windows Hosting Review

ASP.NET Tutorial: How to Use an Example of a Custom Model Binder in ASP.NET Core?

Posted on by Pablo Francesco

The process of converting incoming HTTP request data (such as query string, route values, or request body) to action method parameters in the ASP.NET Core Web API is known as model binding. By default, ASP.NET Core offers robust built-in model binding that functions effectively in the majority of situations.

However, default model binding may not be sufficient in some real-world scenarios. For instance, you could have to interpret complicated formats, merge several inputs, or alter input data. A custom model binder comes in quite handy in these situations.

This article provides step-by-step instructions, examples, and best practices for implementing a custom model binder in ASP.NET Core.

What is Model Binding in ASP.NET Core?

Model binding is a mechanism that automatically maps data from an HTTP request to parameters in your controller action.

For example:

[HttpGet]
public IActionResult GetUser(int id)
{
    return Ok(id);
}

Code Explanation

  • ASP.NET Core automatically reads the id value from the query string or route.
  • It converts the value into an integer.
  • The converted value is passed to the action method.

This automatic process is called model binding.

Why Do We Need a Custom Model Binder?

In practical ASP.NET Core Web API development, you may face scenarios where default model binding does not meet your requirements.

Common Scenarios

  • Parsing custom formatted data (e.g., comma-separated values)
  • Combining multiple request values into a single model
  • Handling special data types
  • Applying custom validation or transformation logic

A custom model binder allows you to control how data is read, processed, and assigned to your model.

Step 1: Create a Custom Model

Let’s create a simple model that represents a date range.

public class DateRange
{
    public DateTime From { get; set; }
    public DateTime To { get; set; }
}

Explanation

This model will hold two values: start date and end date.

Step 2: Create a Custom Model Binder

Now, create a custom model binder by implementing IModelBinder.

using Microsoft.AspNetCore.Mvc.ModelBinding;
using System;
using System.Threading.Tasks;

public class DateRangeModelBinder : IModelBinder
{
    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        var value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName).FirstValue;

        if (string.IsNullOrEmpty(value))
        {
            return Task.CompletedTask;
        }

        var dates = value.Split(',');

        if (dates.Length != 2)
        {
            bindingContext.ModelState.AddModelError(bindingContext.ModelName, "Invalid date range format");
            return Task.CompletedTask;
        }

        var model = new DateRange
        {
            From = DateTime.Parse(dates[0]),
            To = DateTime.Parse(dates[1])
        };

        bindingContext.Result = ModelBindingResult.Success(model);
        return Task.CompletedTask;
    }
}

Code Explanation

  • The binder reads raw input using ValueProvider.
  • It extracts the value from the request.
  • The value is split into two parts using a comma.
  • Each part is converted into DateTime.
  • A new DateRange object is created and returned.

Step 3: Create a Model Binder Provider (Optional but Recommended)

A model binder provider helps ASP.NET Core decide when to use your custom binder.

using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ModelBinding.Binders;

public class DateRangeModelBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context.Metadata.ModelType == typeof(DateRange))
        {
            return new BinderTypeModelBinder(typeof(DateRangeModelBinder));
        }

        return null;
    }
}

Code Explanation

  • The provider checks the model type.
  • If the type matches DateRange, it returns the custom binder.
  • Otherwise, default binding continues.

Step 4: Register the Model Binder Provider

Now register the provider in Program.cs.

builder.Services.AddControllers(options =>
{
    options.ModelBinderProviders.Insert(0, new DateRangeModelBinderProvider());
});

Explanation

  • The provider is added at the top of the list.
  • This ensures your binder is used before default binders.

Step 5: Use the Custom Model Binder in Controller

Now use the custom binder in your controller.

[HttpGet]
public IActionResult GetData([FromQuery] DateRange dateRange)
{
    return Ok(new
    {
        Start = dateRange.From,
        End = dateRange.To
    });
}

Example Request

GET /api/data?dateRange=2024-01-01,2024-01-31

Code Explanation

  • The query string contains a comma-separated date range.
  • The custom binder parses the string.
  • It converts it into a DateRange object.
  • The controller receives a fully populated model.

Real-World Use Cases

Custom model binders are widely used in ASP.NET Core applications:

  • Handling complex query parameters
  • Parsing custom data formats
  • Converting string input into domain models
  • Supporting advanced filtering in APIs

Advantages of Custom Model Binder

  • Full control over data binding
  • Cleaner controller code
  • Reusable logic across endpoints
  • Better handling of complex inputs

Disadvantages of Custom Model Binder

  • Adds extra complexity to the project
  • Requires careful error handling
  • Can be overkill for simple scenarios

Best Practices

  • Use custom model binders only when necessary
  • Keep binding logic simple and focused
  • Validate input properly
  • Avoid heavy business logic inside binders
  • Combine with validation filters if needed

Summary

You can manage how incoming request data is transformed into models in ASP.NET Core by using a custom model binder. When working with complicated or non-standard input formats, it is extremely helpful. You may enhance code structure, cut down on duplication, and better manage complex scenarios in your Web API applications by putting in place a custom binder.

Best ASP.NET Core 10.0 Hosting

The feature and reliability are the most important things when choosing a good ASP.NET Core 10.0 hosting. HostForLIFE is the leading provider of Windows hosting and affordable ASP.NET Core , their servers are optimized for PHP web applications such as the latest ASP.NET Core 10.0 version. The performance and the uptime of the ASP.NET Core  hosting service are excellent, and the features of the web hosting plan are even greater than what many hosting providers ask you to pay for. At HostForLIFE.eu, customers can also experience fast ASP.NET Core hosting. The company invested a lot of money to ensure the best and fastest performance of the datacenters, servers, network and other facilities. Its data centers are equipped with top equipment like cooling system, fire detection, high-speed Internet connection, and so on. That is why HostForLIFE.eu guarantees 99.9% uptime for ASP.NET Core . And the engineers do regular maintenance and monitoring works to assure its ASP.NET Core  hosting are security and always up.

hostforlifebanner