ASP.NET Core Localization with Automated Translations via Result Filters

In my previous post on localization in a .NET Core Web API, I covered the basics of setting up localization and translating API responses into different languages based on the user’s requested language.

In that example, we localized a single string field in the API response. However, in real-world applications, we often need to localize multiple fields. In this post, we’ll extend the previous example and explore a technique to localize multiple fields dynamically—without manually applying localization logic in every controller.

Note. I’ll be repeating some steps from the previous post but won’t go into detailed explanations. If you need a deeper understanding, please check out the previous post.

Creating the Sample Application

Set Up the Project

First, create a new Web API project using the .NET CLI or Visual Studio.

dotnet new webapi -n WebApiLocalization
cd WebApiLocalization

Define the Data Models

Create a User class and two enums (Gender and Status) to represent our data.

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Gender Gender { get; set; }
    public Status Status { get; set; }
}

public enum Gender
{
    Male,
    Female,
    Other
}

public enum Status
{
    Active,
    Inactive,
    Pending
}

Add Sample Data

Create a helper class to provide some test data.

public static class DataHelper
{
    public static List<User> GetUsers()
    {
        return
        [
            new User { Id = 1, Name = "Alice", Gender = Gender.Female, Status = Status.Active },
            new User { Id = 2, Name = "Bob", Gender = Gender.Male, Status = Status.Inactive },
            new User { Id = 3, Name = "Gamma", Gender = Gender.Other, Status = Status.Pending }
        ];
    }
}

Setting Up Localization

Set Up Resource Files

Resource files store translated text. Here’s how to set them up.

Create a Resources folder in your project.
Add a marker class called SharedResource.
```
public class SharedResource
{
}
```
Add two resource files.
- SharedResource.en.resx (for English)
- SharedResource.fr.resx (for French)

Resource File Content

SharedResource.en.resx

Female → Female  
Male   → Male  
Other  → Other  
Active → Active  
Inactive → Inactive  
Pending → Pending

SharedResource.fr.resx

Female  → Femme  
Male    → Homme  
Other   → Autre  
Active  → Actif  
Inactive → Inactif  
Pending → En attente

Create the Localization Service

We’ll create a custom service to handle translations.

public interface IAppLocalizer
{
    string Localize(string key);
}

public class AppLocalizer : IAppLocalizer
{
    private readonly IStringLocalizer _localizer;

    public AppLocalizer(IStringLocalizerFactory factory)
    {
        var type = typeof(SharedResource);
        var assemblyName = new AssemblyName(type.GetTypeInfo().Assembly.FullName);
        _localizer = factory.Create("SharedResource", assemblyName.Name);
    }

    public string Localize(string key) => _localizer[key];
}

Configure the Application

Update Program.cs to enable localization.

var builder = WebApplication.CreateBuilder(args);

// Add localization services
builder.Services.AddLocalization(options => options.ResourcesPath = "Resources");
builder.Services.AddScoped<IAppLocalizer, AppLocalizer>();

builder.Services.AddControllers();
builder.Services.AddOpenApi();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.MapOpenApi();
}

// Set up supported languages
var supportedCultures = new[] { "en", "fr" };
var localizationOptions = new RequestLocalizationOptions()
    .SetDefaultCulture(supportedCultures[0])
    .AddSupportedCultures(supportedCultures)
    .AddSupportedUICultures(supportedCultures);
localizationOptions.RequestCultureProviders.Insert(0, new AcceptLanguageHeaderRequestCultureProvider());
app.UseRequestLocalization(localizationOptions);

app.UseAuthorization();
app.MapControllers();
app.Run();

Building the API Endpoint

Create the API Response DTO

First, create a DTO to structure our response.

public class UserDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Gender { get; set; }
    public string Status { get; set; }
}

Implement the Controller

Create an API controller to return localized data.

[ApiController]
public class UserController(IAppLocalizer localizer) : ControllerBase
{
    [HttpGet("users")]
    public IActionResult GetAll()
    {
        var users = DataHelper.GetUsers().Select(user => new UserDto
        {
            Id = user.Id,
            Gender = localizer.Localize(user.Gender.ToString()),
            Name = user.Name,
            Status = localizer.Localize(user.Status.ToString())
        });

        return Ok(users);
    }
}

Testing the API

You can test the API using cURL or any API testing tool.

# Request in English
curl -X GET "http://localhost:5127/users" -H "Accept-Language: en"

# Request in French
curl -X GET "http://localhost:5127/users" -H "Accept-Language: fr"

API

We can see that both the Gender and Status fields are localized in the responses. This is perfectly fine but we have an opportunity to make this even better.

Right now, the controller calls the localizer.Localize() for each field that needs translation. While this approach works, it requires manually applying localization in the code where it's needed.

What if we could simply mark which fields should be localized and let a centralized logic handle it automatically? This would keep our code cleaner and reduce duplication. Let’s see how to achieve this.

Automating Localization with Attributes and Filters

Create a Localizable Attribute

We’ll create a custom attribute to mark fields that require localization.

[AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
public class LocalizableAttribute : Attribute
{
}

Apply the Localizable Attribute

Decorate the DTO properties that should be localized with the attribute.

public class UserDto
{
    public int Id { get; set; }
    public string Name { get; set; }

    [Localizable]
    public string Gender { get; set; }

    [Localizable]
    public string Status { get; set; }
}

Create a Result Filter for Localization

We can leverage ASP.NET Core Result Filters to apply localization dynamically.

In ASP.NET Core, a Result Filter is a type of filter that allows you to modify or inspect the result of an action method before it is sent to the client. Result filters run after the action method has executed but before the response is finalized.

We shall create a result filter that does the following.

Detect all Localizable properties in the API response.
Automatically localize these fields in the response using our IAppLocalizer.
Work with both simple objects and collections.

public class LocalizableResultFilter(IAppLocalizer localizer) : IAsyncResultFilter
{
    public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next)
    {
        if (context.Result is ObjectResult objectResult && objectResult.Value != null)
        {
            // Process single object or collection and localize the values
            objectResult.Value = LocalizeString(objectResult.Value);
        }

        await next();
    }

    private object LocalizeString(object obj)
    {
        if (obj == null) return null;

        // If it's a collection, process each item. Exclude strings from this condition as strings are also IEnumerable
        if (obj is IEnumerable collection && obj is not string)
        {
            var list = collection.Cast<object>().ToList();
            for (int i = 0; i < list.Count; i++)
            {
                list[i] = LocalizeString(list[i]);
            }
            return list;
        }

        // If it's a single object, process its public string properties decorated with LocalizableAttribute
        var objType = obj.GetType();
        foreach (var prop in objType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
        {
            if (prop.PropertyType == typeof(string)
                && prop.CanWrite
                && prop.GetCustomAttributes(typeof(LocalizableAttribute), true).Length != 0)
            {
                if (prop.GetValue(obj) is string value)
                {
                    string localizedValue = localizer.Localize(value.ToString());
                    prop.SetValue(obj, localizedValue);
                }
            }
            else if (!prop.PropertyType.IsPrimitive && prop.PropertyType != typeof(DateTime))
            {
                // If it's a complex object, recursively process it
                var propValue = prop.GetValue(obj);
                prop.SetValue(obj, LocalizeString(propValue));
            }
        }

        return obj;
    }
}

Register the Filter in the Program.cs

Enable the filter globally.

builder.Services.AddControllers(opt =>
{
    opt.Filters.Add<LocalizableResultFilter>();
});

Update the Controller

Now, we no longer need to call the localizer.Localize() inside the controller. We simply return the DTO, and the result filter handles localization.

[ApiController]
public class UserController : ControllerBase
{
    [HttpGet("users")]
    public IActionResult GetAll()
    {
        var users = DataHelper.GetUsers().Select(user => new UserDto
        {
            Id = user.Id,
            Gender = user.Gender.ToString(),
            Name = user.Name,
            Status = user.Status.ToString()
        });

        return Ok(users);
    }
}

Final Testing

Run the API and test it again.

curl -X GET "http://localhost:5127/users" -H "Accept-Language: en"
curl -X GET "http://localhost:5127/users" -H "Accept-Language: fr"

Final Testing

Now, localization happens automatically for all marked fields, making the controller cleaner and reducing duplicate code.

Summary

We started with basic localization in a .NET Core Web API.
Instead of manually localizing each field, we created a Localizable attribute.
We used Result Filters to automatically apply localization to marked fields.
This approach makes the API cleaner and easier to maintain.

Now, localization is handled dynamically with minimal changes to the API code!