DEV Community: Pascal Vorwerk

LeetCode: Problem 2016

Pascal Vorwerk — Mon, 16 Jun 2025 18:49:10 +0000

Date of writing: 16-06-2025

The problem

Given a 0-indexed integer array nums of size n, find the maximum difference between nums[i] and nums[j] (i.e., nums[j] - nums[i]), 
such that 0 <= i < j < n and nums[i] < nums[j].

Return the maximum difference. If no such i and j exists, return -1.

First thoughts

This problem, in initial thought, seems pretty simple. We simply need to find the biggest difference between 2 numbers, if the latter of those 2 numbers is bigger then first number.

I believe we can do this in a O(n) solution, keeping track of some numbers whilst we go through the list!

The first pseudo code I can think of is as follows:

const maxDifference = -1;
const smallestIndex = 0;

for (int i = 0; i < numbers.length; i++){

    if i is equal to numbers.length - 1 :
        // We are at the end of the list, so we should only check numbers[i]

        if numbers[i] is larger then smallest:
            maxDifference is now numbers[i] - numbers[smallestIndex]

    // For each other situation, we can compare numbers[i] with numbers[i + 1]

    // First, let's check if the i + 1 is a smaller number, if so we can set that as the new smallestIndex and continue

    if numbers[i + 1] <= numbers[i] :
        smallestIndex = i + 1
        continue


    // Now, we can assume numbers[i + j] is larger then numbers[i], but we have to check if the difference is larger than what we previously had

    if (numbers[i + 1] - numbers[i]) > maxDifference:
        // We have found a new maxDifference!
        maxDifference = numbers[i + 1] - numbers[i]

        // The smallest index remains the same, as the next number might be even bigger! or smaller..
    }

Implementation

The pseudo code is already pretty elaborate, but here is the first attempt at the complete c# function:

public static (int, int, int) DetermineDifference(int[] nums)
    {
        if (nums.Length < 2)
        {
            return (-1, -1, -1); // Not enough elements to find a difference
        }

        int maxDifference = -1;
        int smallestIndex = 0;
        int largestIndex = 0;

        for (int i = 0; i < nums.Length; i++)
        {
            if (i == nums.Length)
            {
                // We are at the end of the list, so we should only check numbers[i]
                if (nums[i] > nums[smallestIndex])
                {
                    maxDifference = nums[i] - nums[smallestIndex];
                }
                continue;
            }

            // For each other situation, we can compare numbers[i] with numbers[i + 1]

            // First, let's check if the i + 1 is a smaller number, if so we can set that as the new smallestIndex and continue
            if (i + 1 < nums.Length && nums[i + 1] < nums[smallestIndex])
            {
                smallestIndex = i + 1;
                continue;
            }

            // Now, we can assume numbers[i + j] is larger then numbers[i], but we have to check if the difference is larger than what we previously had

            if (nums[i + 1] - nums[smallestIndex] > maxDifference)
            {
                maxDifference = nums[i + 1] - nums[smallestIndex];
                largestIndex = i + 1;
            }
        }


        return (maxDifference, smallestIndex, largestIndex);
    }

Results of try number 1!

Okay, so the little console application we have will ask how large the list must be (although within the constraints) and generate a list with random numbers between 1 and 100. We will keep the number relatively low so we can actually make sure ourselves if the calculation is correct!

Also, to make it easier to determine where the indexes are, we return all 3 the numbers.

.. Oops.. We are clearly doing something wrong at the end of our for loop..

Okay! After some debugging we found that the issue was we are still getting to the last index, I made a mistake with the nums.Length, thinking this would be 0 based, but ofcourse it is not. So with a simple fix we have now solved that bug:

if (i + 1 == nums.Length){ // Or nums.Length - 1
    if (nums[i] > nums[smallestIndex]){
        maxDifference = nums[i] - nums[smallestIndex];
    }
    continue;
}

Try number 2

Let's see what we get now when we run our program:

Nope.. we are still doing something wrong. Clearly, the maximum difference should have been 86 - 16 = 70, but somehow the values after it still got there.

Let's rethink some things:

First of all, we don't really need to iterate over the first element, as we can simply record that value and assume that will be the lowest.
Right now, we are iterating and comparing one step ahead, but instead of that, we can keep track of the smallest index and compare with the current index.
The smallest index in the array might not be the actual smallest index we need for our 'largest' difference! For example: [5, 10, 4, 6, 7].

This might actually make our algorithm a lot easier aswell.. Let's try to write some pseudocode first again:

int maxDifference = -1;
int lowIndex = 0; // This is the final low index we used
int maxIndex = 0; // This is the final max index we used

int currentLowIndex = 0;
int currentLowValue = nums[0] // To make it easier to reference later..

for (int i = 1; i < nums.Length; i++){
    // If nums[i] - currentLowValue is larger then maxDifference, we have a new maxDifference!
    if nums[i] - currentLowValue > maxDifference:
        maxDifference = nums[i] - currentLowValue;
        lowIndex = currentLowIndex // Keep track of the current Low index we used for this max index!
        largestIndex = i;

    // Additionally we need to check if the current index is at all lower then our current lowest value
    if nums[i] is lower then currentLowValue:
        currentLowValue = nums[i]
        currentLowIndex = i // Keep track of the currently used minimum index aswell!

}

Let's try to write this up in a function

 public static (int, int, int) DetermineDifference2(int[] nums)
    {
        if (nums.Length < 2)
        {
            return (-1, -1, -1); // Not enough elements to find a difference
        }

        int maxDifference = -1;
        int lowIndex = 0;
        int maxIndex = 0;

        int currentLowIndex = 0;
        int currentLowValue = nums[0];

        for (int i = 1; i < nums.Length; i++)
        {
            // If nums[i] - currentLowValue is larger then maxDifference, we have a new maxDifference!
            if (nums[i] - currentLowValue > maxDifference)
            {
                maxDifference = nums[i] - currentLowValue;
                lowIndex = currentLowIndex; // Keep track of the current Low index
                maxIndex = i;
            }


            // Additionally we need to check if the current index is at all lower then our current lowest value
            if (nums[i] < currentLowValue)
            {
                currentLowValue = nums[i];
                currentLowIndex = i; // Keep track of the currently used minimum index aswell!
            }
        }

        return (maxDifference, lowIndex, maxIndex);
    }

Try number 3!

We hooked this method up to our console application and let's see the result!

This seems correct! Indeed, the largest difference is between '1' and '63', the value of 62!

Let's try 2 more with larger lists..

Now this one also still seems to work, indeed the largest difference i can spot with my human eyes is between 4 and 76, index 1 and 5.

A final one! Then we will submit this solution to Leetcode if it passes!

Indeed, again, the largest difference seems to be between the number 2 and 99, on index 3 and 17!

Results on LeetCode, was our algorithm fast or slow?

Darn! Still no correct solution! It seems like we missed some edge cases, which ofcourse makes sense as we only used random numbers.. Hitting those edge cases would be pretty hard. Maybe we should have done some Test Driven Development?

It seems like we missed the edge case where the difference might be 0 between 2 items, but the algorithm expects to still output -1, not 0.. Let's fix this in our code:

int currentDiff = nums[i] - currentLowValue;

if (currentDiff > maxDifference && currentDiff > 0)
{
    maxDifference = nums[i] - currentLowValue;
    lowIndex = currentLowIndex;
    maxIndex = i;
}

Okay... Let's try again!

Final thoughts

Even though this is marked as 'easy' on Leetcode, we still had some trouble making sure our algorithm worked and no edge cases made it past the tests! Does that make me a bad programmer? I am not sure, what do you think, but I won't let it keep me down! On to the next LeetCode problem!

I encourage you to also try these problems, they help a lot with problem solving skills, which is helpful for any programmer, not only people that are hunting jobs at the biggest and best companies!

Don't fall into the trap of using AI to solve the problems.. you won't learn nearly as much from it!

The code for all this can be found here: https://github.com/PascalVorwerk/blogs

Validation in Blazor

Pascal Vorwerk — Fri, 23 May 2025 19:46:47 +0000

Blazor and validation

In the previous post we took a look at setting up validation, using Data Annotations and IValidatableObject. In this blog we will take a look at how we can use this validation in a Blazor project. We will define a few rules/requirements to make the sample more clear:

We will be simulating a real database, but we will not set up a real connection.
We will not take into account security.
We will disable prerendering for our Blazor application. Prerendering causes additional headaches for our pages, which are really out of scope for this blog post!

Domain and rules

Our domain is pretty simple! We will have a list of users, which we can retrieve and create! A user will look like so:

[Index(nameof(Email), IsUnique = true)]
public class User
{
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public Guid Id { get; set; }

    [StringLength(AppConstants.EmailMaxLength, MinimumLength = 0)]
    public string Email { get; set; } = null!;

    [StringLength(AppConstants.NameMaxLength, MinimumLength = 0)]
    public string Name { get; set; } = null!;

    [StringLength(AppConstants.SurnameMaxLength, MinimumLength = 0)]
    public string Surname { get; set; } = null!;

    [Range(AppConstants.AgeMinValue, AppConstants.AgeMaxValue)]
    public int Age { get; set; }
}

public class AppConstants
{
    public const int EmailMaxLength = 256;
    public const int NameMaxLength = 50;
    public const int SurnameMaxLength = 50;
    public const int AgeMaxValue = 120;
    public const int AgeMinValue = 0;
}

Note that we have defined Data annotations on these properties. These annotations will usually help define constraints for tools like Entity framework for the database. This is different per tool, but it is usually something you want to look at when working with ORM's.

We can define some of the following validation/business rules when we look at our User model:

We need to adhere to the length constraints that are defined by the model, otherwise we will likely get some database exceptions!
There is a unique index on the email, makes sense, however we would ideally deal with this before we reach the database and catch some nasty exceptions.
None of the properties are nullable, which means each property needs a value.

The request

Looking at these rules and constraints, we can define a model that we will receive when a user wants to create a user:

public class CreateUserRequest : IValidatableObject
{
    [Required]
    [StringLength(AppConstants.EmailMaxLength, MinimumLength = 0)]
    [EmailAddress]
    public string Email { get; set; } = null!;

    [Required]
    [StringLength(AppConstants.NameMaxLength, MinimumLength = 0)]
    public string Name { get; set; } = null!;

    [Required]
    [StringLength(AppConstants.SurnameMaxLength, MinimumLength = 0)]    
    public string Surname { get; set; } = null!;

    [Required]
    [Range(AppConstants.AgeMinValue, AppConstants.AgeMaxValue)]
    public int Age { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {
        // How do we make sure the email is unique?

        return new List<ValidationResult>();
    }
}

Some things to see in the previous code:

We can use the build-in [EmailAddress] enum to make sure the Emailaddress is an emailaddress.
We have to specify each property is required for validation.
We haven't dealt with the unique email address rule!

How do we deal with that last point? To check whether a email is unique, we will need to reach our 'database'.

One place for all business logic

Luckily, using the validation context in the validate method, we can access any service provider that was given to the validation context! In our ValidationFilter, the one we made in the previous blog, we do the following:

        var argument = context.Arguments.OfType<T>().FirstOrDefault();

        if (argument == null)
        {
            return Results.BadRequest("Invalid request payload");
        }

        var validationContext = new ValidationContext(argument, serviceProvider: context.HttpContext.RequestServices, items: null);
        var validationResults = new List<ValidationResult>();

This adds the service provider that is known to the Http request pipeline to the validation context. This custom validation filter is something that is not needed anymore for dotnet 10, and in dotnet 10 any validation context should already contain the service collection needed!

This now means we can supply any service or database we have on the server side to the method!

The user service

Our user service is really simpel, as we are not REALLY going to a database. This could easily be replaced with any EF Core repository pattern:

public interface IUserService
{
    Task<List<GetUserResponse>> GetUsersAsync();
    Task<GetUserResponse> GetUserAsync(Guid id);
    Task<GetUserResponse?> GetUserByEmailAsync(string email);
    Task<Guid> CreateUserAsync(CreateUserRequest request);
}

public class UserService : IUserService
{
    public Task<List<GetUserResponse>> GetUsersAsync()
    {
        var users = UsersDatabase.GetUsers()
            .Select(x => new GetUserResponse(x.Id, x.Email, x.Name, x.Surname, x.Age))
            .ToList();

        return Task.FromResult(users);
    }

    public Task<GetUserResponse> GetUserAsync(Guid id)
    {
        var user = UsersDatabase.GetUser(id);

        if (user == null)
            throw new Exception("User not found");

        var userResponse = new GetUserResponse(user.Id, user.Email, user.Name, user.Surname, user.Age);

        return Task.FromResult(userResponse);
    }

    public Task<GetUserResponse?> GetUserByEmailAsync(string email)
    {
        var user = UsersDatabase.GetUsers().FirstOrDefault(x => x.Email == email);

        return Task.FromResult(user != null ? new GetUserResponse(user.Id, user.Email, user.Name, user.Surname, user.Age) : null);
    }

    public Task<Guid> CreateUserAsync(CreateUserRequest request)
    {
        var user = new User
        {
            Id = Guid.NewGuid(),
            Email = request.Email,
            Name = request.Name,
            Surname = request.Surname,
            Age = request.Age
        };

        UsersDatabase.AddUser(user);

        return Task.FromResult(user.Id);
    }
}

The new validation method

Now that we have defined our new user service, we can use it in our validation context service provider like so:

public class CreateUserRequest : IValidatableObject
{
    [Required]
    [StringLength(AppConstants.EmailMaxLength, MinimumLength = 0)]
    [EmailAddress]
    public string Email { get; set; } = null!;

    [Required]
    [StringLength(AppConstants.NameMaxLength, MinimumLength = 0)]
    public string Name { get; set; } = null!;

    [Required]
    [StringLength(AppConstants.SurnameMaxLength, MinimumLength = 0)]    
    public string Surname { get; set; } = null!;

    [Required]
    [Range(AppConstants.AgeMinValue, AppConstants.AgeMaxValue)]
    public int Age { get; set; }

    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {
        // The userService is resolved on the server side, from the Service provider.
        var userService = validationContext.GetService<IUserService>();

        // Check if the email already exists
        var emailExists = userService?.GetUserByEmail(Email);

        if (emailExists != null)
        {
            yield return new ValidationResult("Email already exists", [nameof(Email)]);
        }
    }
}

As you can see, we are explicitly making sure the user service is available! This is because with Blazor, the validation can be performed on both the client and the server!

We only want to perform the email 'unique' check whenever we have reached the server and the user service is available!!

Note: I have tried implementing a client side user service that performs an API call to check for email uniques on the server, however, the current implementation of IValidateableObject is not compatible with async calls.. This would be a great feature to add I think!

With this approach, any client side validation that can happen before we reach the server will happen, but also any validation that can only happen once we reach the server can also happen! Now the next step.. how can we use this in Blazor and EditForms??

Using the validation in Blazor

Using the validation we have defined on our request in a Blazor is pretty simple, although it does require some setting up.

First, we must setup the razor components to receive our input. We can use the default components blazor provides for this!

<div style="display: flex; align-items: center; flex-direction: column; width: 100%">
    <h3 class="text-xl font-bold mb-4">Create User</h3>

    <div style="width: 500px;">
        <EditForm EditContext="@_editContext" OnValidSubmit="HandleValidSubmit">
            <DataAnnotationsValidator />

            <div class="mb-3">
                <label>Email:</label>
                <InputText @bind-Value="_user.Email" class="form-control" />
                <ValidationMessage For="@(() => _user.Email)" />
            </div>

            <div class="mb-3">
                <label>Name:</label>
                <InputText @bind-Value="_user.Name" class="form-control" />
                <ValidationMessage For="@(() => _user.Name)" />
            </div>

            <div class="mb-3">
                <label>Surname:</label>
                <InputText @bind-Value="_user.Surname" class="form-control" />
                <ValidationMessage For="@(() => _user.Surname)" />
            </div>

            <div class="mb-3">
                <label>Age:</label>
                <InputNumber @bind-Value="_user.Age" class="form-control" />
                <ValidationMessage For="@(() => _user.Age)" />
            </div>

            <button class="btn btn-primary" type="submit">Submit</button>
        </EditForm>
    </div>
</div>

@code {
    private readonly CreateUserRequest _user = new();
    private EditContext? _editContext;
    private ValidationMessageStore? _messageStore;

    protected override void OnInitialized()
    {
        _editContext = new EditContext(_user);
        _messageStore = new ValidationMessageStore(_editContext);
    }

    private async Task HandleValidSubmit()
    {
        // Clear previous messages
        _messageStore?.Clear();
        _editContext?.NotifyValidationStateChanged();

        var response = await HttpClient.PostAsJsonAsync("api/users", _user);

        if (response.IsSuccessStatusCode)
        {
            var result = await response.Content.ReadFromJsonAsync<Guid>();
            Console.WriteLine($"User created with ID: {result}");
            return;
        }

        if (response.StatusCode == HttpStatusCode.BadRequest)
        {
            var content = await response.Content.ReadAsStringAsync();

            // Minimal inline deserialization to avoid referencing ASP.NET Core types
            var problemDetails = System.Text.Json.JsonSerializer.Deserialize<ClientValidationProblemDetails>(content,
                new System.Text.Json.JsonSerializerOptions
                {
                    PropertyNameCaseInsensitive = true
                });

            if (problemDetails?.Errors is not null)
            {
                foreach (var (field, messages) in problemDetails.Errors)
                {
                    var fieldIdentifier = new FieldIdentifier(_user, field);

                    foreach (var message in messages)
                    {
                        _messageStore?.Add(fieldIdentifier, message);
                    }
                }

                _editContext?.NotifyValidationStateChanged();
            }

            return;
        }

        // Handle other errors
        var errorContent = await response.Content.ReadAsStringAsync();
        Console.Error.WriteLine($"Unexpected error: {(int)response.StatusCode} - {errorContent}");
    }
}

In this code, we are using the default DataAnnotationsValidator to perform the validation on our fields and when the form is submitted. We will show a validation message for each field below the input of that field!

Great! Let's look at the result and what happens if we type in some wrong inputs!

Great! This works as expected! Now, let's see what happens when we create a new user with valid input.

This results in a nice response with the new user id as a result.

Our form doesn't really handle the correct response at all, it simply logs the user ID. Normally, you would likely show some result message and navigate to the newly created user!

However, let's make sure we can't add this user twice! The user is now added to our static list (or database), so the server should return a error whenever we submit the same email. Let's check.

As you can see, the server returned a validation problem details and we correctly parsed it to add the validation problems to our message store!

Now we can use all of our validation logic, that is defined in one place, in both Blazor AND our API!

Summary

In this post, we:

Reused our shared validation logic (Data Annotations + IValidatableObject) in both Web API's and Blazor.
Showed how to access IServiceProvider in ValidationContext to perform server-side checks (like email uniqueness).
Demonstrated how to display server-side validation errors in a Blazor EditForm using ValidationMessageStore.

All the code for this example is available in the (ValidationBlazor folder on GitHub)[https://github.com/PascalVorwerk/blogs/tree/main/ValidationBlazor].

Feel free to explore the code, ask questions, and suggest improvements!!

Want to learn about validation in ASP.NET Core with minimal API's? Check this blog!

Pascal Vorwerk — Thu, 15 May 2025 18:50:00 +0000

Pascal Vorwerk

May 15 '25

Validation made simple!

#dotnet #programming #minimalapis #beginners

Comments

5 min read

Validation made simple!

Pascal Vorwerk — Thu, 15 May 2025 17:53:53 +0000

Validation in ASP.NET Core for Minimal API's (and a look at .NET 10)

Validation is probably the most important step when retrieving input values in your API! In the past, I have often used libraries like FluentValidation to perform validation in my API's. However, now that this library is going to become commercial, I went to investigate how to perform the same operations this library enables through the standard ways.

None of this is rocket science or not described by the original documentation of Asp.Net Core. This blog is simply to provide a quick start to setup validation!

Who would have guessed.. weatherforecasts!

First, let's start by defining our model we wan't to create an API around! Oh look at that, what a suprise.. the good old Weatherforecast..

public record WeatherForecast(DateOnly Date, int TemperatureC, string? Summary)
{
    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
}

Great.. Let's try to simulate some kind of database setting for demo purposes.

public static class WeatherData
{
    private static List<WeatherForecast> _weatherForecasts = new();
    private static readonly string[] Summaries =
    [
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    ];

    public static void Initialize()
    {

        _weatherForecasts = Enumerable.Range(1, 5).Select(index =>
                new WeatherForecast
                (
                    DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
                    Random.Shared.Next(-20, 55),
                    Summaries[Random.Shared.Next(Summaries.Length)]
                ))
            .ToList();
    }

    public static List<WeatherForecast> GetWeatherForecasts()
    {
        return _weatherForecasts;
    }

    public static void AddWeatherForecast(WeatherForecast weatherForecast)
    {
        _weatherForecasts.Add(weatherForecast);
    }

    public static void UpdateWeatherForecast(WeatherForecast weatherForecast)
    {
        var index = _weatherForecasts.FindIndex(w => w.Date == weatherForecast.Date);
        if (index != -1)
        {
            _weatherForecasts[index] = weatherForecast;
        }
    }

    public static void DeleteWeatherForecast(DateOnly date)
    {
        var index = _weatherForecasts.FindIndex(w => w.Date == date);
        if (index != -1)
        {
            _weatherForecasts.RemoveAt(index);
        }
    }
}

Endpoints

Great! Now that that is place, we will define a few endpoints following the REST design principles:

var group = endpoints.MapGroup("/api/weatherforecasts")
            .WithTags("WeatherForecast");

group.MapGet("/", GetAllWeatherForeCasts); // Get all weatherforecasts
group.MapPost("/", CreateWeatherForecast); // Create a new weatherforecast
group.MapPut("/date:datetime", UpdateWeatherForecast); // Update a weatherforecast
group.MapDelete("/date:datetime", DeleteWeatherForecast); // Delete a weatherforecast

Now.. The validation

Usually, most of the time, in a REST design only a few endpoints need validation from user input. The POST and PUT endpoints both receive some kind of user input to create or replace the weather endpoints.

Let's define the models the users can input for each request.

public class CreateWeatherForecastRequest
{
    public DateTime Date { get; set; }

    public int TemperatureC { get; set; }

    public string Summary { get; set; } = string.Empty;
}

public class UpdateWeatherForecastRequest
{
    public int TemperatureC { get; set; }

    public string Summary { get; set; } = string.Empty;
}

Data annotations

The first thing we can do to start validating these models is adding some data annotations. These annotations can be used for basic and simple requirements on the data you receive.

Let's apply a few notations to our models:

public class CreateWeatherForecastRequest
{
    [Required]
    public DateTime Date { get; set; }

    [Required]
    [Range(-20, 55)]
    public int TemperatureC { get; set; }

    [Required]
    [StringLength(50)]
    public string Summary { get; set; } = string.Empty;
}

public class UpdateWeatherForecastRequest
{
    [Required]
    [Range(-20, 55)]
    public int TemperatureC { get; set; }

    [Required]
    [StringLength(50)]
    public string Summary { get; set; } = string.Empty;
}

IValidatableObject

Great! However, sometimes we need to handle some more complex rules. For example, can we really classify a -20 degree temperature as a 'Hot' summary? How do validate these types of business rules? For this, we can implement the IValidateableObject interface!

public class CreateWeatherForecastRequest : IValidatableObject
{
    [Required]
    public DateTime Date { get; set; }

    [Required]
    [Range(-20, 55)]
    public int TemperatureC { get; set; }

    [Required]
    [StringLength(50)]
    public string Summary { get; set; } = string.Empty;

    public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
    {
        // Here you can add custom validation logic if needed

        // Example: A -20 temperature cannot have a "Hot" summary..
        if (TemperatureC == -20 && Summary.Equals("Hot", StringComparison.OrdinalIgnoreCase))
        {
            yield return new ValidationResult(
                "A temperature of -20 cannot have a 'Hot' summary.",
                [nameof(Summary)]);
        }

        // Or.. the date must be in the future
        if (Date <= DateTime.Now)
        {
            yield return new ValidationResult(
                "The date must be in the future.",
                [nameof(Date)]);
        }
    }
}

Here you can see some additional business rules we came up with for creating a new weather forecast!

Now.. how do we start using these attributes and this new method that has been implemented?

ValidationFilter

For controller API's, you don't need to do anything else then register the model your endpoint. The pipeline will automatically perform the validation on both the data annotations and call the Validate method. However, in .NET 9, minimal API's need to manually setup these steps. In .NET 10, this gets simplified (see).

Because of this, I have made a filter one can add to the endpoints you want to validate.

public class ValidationFilter<T> : IEndpointFilter where T : class
{
    public async ValueTask<object?> InvokeAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
    {
        var argument = context.Arguments.OfType<T>().FirstOrDefault();

        if (argument == null)
        {
            return Results.BadRequest("Invalid request payload");
        }

        var validationContext = new ValidationContext(argument);
        var validationResults = new List<ValidationResult>();

        // This call validates all properties of the object, or only the required ones if 'ValidateAllProperties' is set to false
        Validator.TryValidateObject(argument, validationContext, validationResults, true);

        // If there are no validation results, we can continue in the pipeline
        if (validationResults.Count == 0) return await next(context);

        var errorDict = new Dictionary<string, List<string>>();

        foreach (var result in validationResults)
        {
            var memberNames = result.MemberNames.Any() ? result.MemberNames : [string.Empty];

            foreach (var memberName in memberNames)
            {
                if (!errorDict.ContainsKey(memberName)) errorDict[memberName] = [];

                errorDict[memberName].Add(result.ErrorMessage ?? "Validation error");
            }
        }

        var finalErrors = errorDict.ToDictionary(
            kvp => kvp.Key,
            kvp => kvp.Value.ToArray()
        );

        return Results.ValidationProblem(finalErrors);
    }
}

Keep in mind that this is only needed for now, this is not needed anymore once we can add validation to our minimal API's in .NET 10!

If you don't want to use a filter, you can simply validate the object at the start of your endpoint method:

       // Update an existing weather forecast
        group.MapPut("/{date:datetime}", ([FromRoute] DateTime date, [FromBody] UpdateWeatherForecastRequest request) =>
        {
            // Because no validation filter was added to the route, it is not validated. We can however still manually validate the object..
            var validationContext = new ValidationContext(request);
            var validationResults = new List<ValidationResult>();
            var isValid = Validator.TryValidateObject(request, validationContext, validationResults, true);

            if (!isValid)
            {
                return Results.ValidationProblem(
                    validationResults.ToDictionary<ValidationResult, string, string[]>(v => v.MemberNames.First(), v => [v.ErrorMessage ?? "Not provided"]));
            }


            var weatherForecast = new WeatherForecast(new DateOnly(date.Year, date.Month, date.Day), request.TemperatureC, request.Summary);
            WeatherData.UpdateWeatherForecast(weatherForecast);
            return Results.NoContent();
        });

Result

Let's test our custom rule about having a -20 temperature with a 'Hot' summary!

As we want, this returns a validation details response, telling the consumer about our custom business rule.

Summary

In this blog, we took a quick look at validation for minimal API's in .NET 9, whilst keeping in mind that some things become easier once .NET 10 comes out!

Some other topics I am thinking to elaborate on:

Using this validation in Blazor forms to perform client side validation.
Using custom attributes in validation.
Perform database checking as a validation step in Blazor. For example for unique email checks!

Let me know if you would like me to write a blog for these subjects! Hopefully this blog was helpful for anyone not yet known with validation in ASP.NET Core

All of this code is made available here.