Support for .NET 7 required properties

[Aculeo]

C#11 / .NET 7 has a new feature that allows properties to be marked as required.

Documentation for it: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/required

This is also enforced during JSON deserialization: https://learn.microsoft.com/en-us/dotnet/standard/serialization/system-text-json/required-properties

It seems that when using AutoMapper this isn't enforced though, and this code runs just fine:

using AutoMapper;

var configuration = new MapperConfiguration(cfg => 
{
    cfg.CreateMap<PersonDto, Person>();
});

var mapper = configuration.CreateMapper();

var personDto = new PersonDto
{
    Name = "Test"
};
var person = mapper.Map<Person>(personDto);

Console.WriteLine("Name: " + person.Name);
Console.WriteLine("Address: " + person.Address);

internal class PersonDto
{
    public string Name { get; set; }
}

internal class Person
{
    public required string Name { get; set; }
    public required string Address { get; set; }
}

It shouldn't be possible that Address is empty, ideally this would raise an exception when mapping.

[jbogard]

These are all compiler tricks with C#. There is nothing enforced at runtime. AutoMapper creates code at runtime that bypasses the compiler entirely.

We could investigate raising an exception at configuration validation time, but that would involve us digging in to the compiler-emitted metadata (usually additional attributes on members), and I'm not sure it's worth the effort.

[lbargaoanu]

Actually, in your case, if you validate your configuration, you'll get an error, regardless of required.

[simonachmueller]

I'm running into a similar issue when using collection marked with required, or mapping a nullable collection to not nullable. Configuration validation passed.
UPDATE: collections are mapped differently anyways https://docs.automapper.org/en/latest/Lists-and-arrays.html#handling-null-collections, so destination collection will newer be null but empty collection if you don't specify it explicitly.