The model validation attributes MaxLength/MinLength are incompatible with native-aot

[sudoudaisuke]

I am using System.ComponentModel.DataAnnotations.MaxLengthAttribute for request model validation. However, MaxLengthAttribute is incompatible with native-aot (IL2026). How can I validate my model?
I found a validation option that supports source generation, but not for asp.net.

dotnet: 8.0

https://github.com/dotnet/runtime/blob/main/src/libraries/System.ComponentModel.Annotations/src/System/ComponentModel/DataAnnotations/MaxLengthAttribute.cs#L28

https://learn.microsoft.com/en-us/dotnet/core/extensions/options-validation-generator

[engineering87]

Hello,
have you considered using the [StringLength] attribute or creating a custom validation attribute?

[sudoudaisuke]

Thank you for your response.
I use [StringLength] for strings, but not for arrays.
OpenApi schema has minItems and maxItems for arrays. I want to use MaxLengthAttribute for OpenApi maxItems.

[Digvijay]

Addressing validation attribute AOT compatibility

This is a real gap — System.ComponentModel.DataAnnotations relies on reflection internally, and as you found, several attributes like MaxLengthAttribute carry [RequiresUnreferencedCode] making them incompatible with Native AOT.

You're right that the Options Validation source generator exists for IOptions<T> validation, but there's no equivalent for ASP.NET Core request model validation today.

I built Sannr to address exactly this problem. It's a Roslyn source generator that produces static validation code at compile time — zero reflection, zero System.Reflection.Emit, fully compatible with Native AOT and IL trimming.

For your specific scenario with array length validation:

using Sannr;

public partial class MyRequest
{
    [Required]
    [StringLength(100)]
    public string Name { get; set; }

    [Required]
    [Range(1, 1000)]
    public int[] ItemIds { get; set; }
}

[mr-baraiya]

Native AOT has limitations with some DataAnnotations attributes because they rely on reflection, which is restricted in trimmed/AOT scenarios.

If you specifically need validation for arrays (like minItems / maxItems in OpenAPI), one simple approach is to implement a custom validation attribute that checks the array length without reflection.

Example:

public class ArrayLengthAttribute : ValidationAttribute
{
    public int Max { get; }

    public ArrayLengthAttribute(int max)
    {
        Max = max;
    }

    protected override ValidationResult IsValid(object value, ValidationContext context)
    {
        if (value is Array arr && arr.Length > Max)
            return new ValidationResult($"Maximum allowed items is {Max}");

        return ValidationResult.Success;
    }
}

This avoids some of the trimming/AOT issues while still enabling model validation for arrays.