EF Core custom collections

[fiseni]

Please find the full sample app here (it's a single top-level file).

Background

Now that the record type is introduced, it's common to utilize it for UI models. It's handy for testing, especially the with syntax and the value equality. That said, not rarely do we define custom collection types and use them for inner collections to account for value equality. Let's name it ValueList. Example:

public class BlogProfile : Profile
{
    public BlogProfile()
    {
        CreateMap<Post, PostModel>();
        CreateMap<Blog, BlogModel>();
    }
}

public class Blog
{
    public int Id { get; set; }
    public string? Name { get; set; }

    private readonly List<Post> _posts = new();
    public IEnumerable<Post> Posts => _posts.AsEnumerable();
}

public class Post
{
    public int Id { get; set; }
    public string? Title { get; set; }
}

public record BlogModel
{
    public int Id { get; set; }
    public string? Name { get; set; }
    public ValueList<PostModel> Posts { get; set; } = new();
}

public record PostModel
{
    public int Id { get; set; }
    public string? Title { get; set; }
}

public class ValueList<T> : List<T>
{
    public ValueList(IEnumerable<T> collection)
	: base(collection) {}

    public ValueList() 
	: base() {}

    public ValueList(int capacity)
	: base(capacity)

    public override bool Equals(object? obj)
    {
       // Implementation omitted for brevity.
       // Items are records, we can use Equals to compare items.
    }

    public override int GetHashCode()
    {
       // Implementation omitted for brevity.
    }
}

public static class ValueListExtensions
{
    public static ValueList<T> ToValueList<T>(this IEnumerable<T> collection)
    {
        return new ValueList<T>(collection);
    }
}

Issue

The issue arises during the projection, it's unable to project to these custom collection types. The source of the issue is in EnumerableProjectionMapper since ToList/ToArray extension methods are used to construct the destination inner collection, and that of course fails. Refer to the full sample app here.

// This fails since it's unable to project IEnumerable<Post> to ValueList<Post>.
return await _dbContext.Blogs.AsQueryable()
    .ProjectTo<BlogModel>(_configurationProvider)
    .ToListAsync();

For now, I'm writing my own IProjectionMapper implementation and inserting it to ProjectionMappers (before EnumerableProjectionMapper). But, it would be nice if we have a more robust solution to this.

• Allow us to pass a MethodInfo (this would be weird 😄)
• If the destination inner collection type is already initialized, Clear and Add items perhaps?

Version

AutoMapper Version="11.0.1"
AutoMapper.Extensions.Microsoft.DependencyInjection Version="11.0.0"
Microsoft.EntityFrameworkCore Version="6.0.2"
Microsoft.EntityFrameworkCore.Sqlite Version="6.0.2"

Thank you!

[lbargaoanu]

That's a feature request for EF Core. ProjectTo was designed for EF6 where this was not possible. A PR is welcome.
But what would the simplest possible EF query that does that? Because presumably you want to extend the EnumerableProjectionMapper to do just that.

[fiseni]

Well, since I own the type, I can just use my own extension method ToValueList in the EF query, right? That's what I'm doing in my custom IProjectionMapper implementation too, instead of ToList, I'm using MethodInfo for ToValueList.

How to generalize the solution? Frankly, not sure either 😄 Allowing users to pass a MethodInfo of their extension method would solve everything, but that would be a weird API and I assume you don't want that. The Clear/Add approach, not sure if that would be correctly interpreted by EF Core (we need expressions here). So, I'm out of ideas.

[fiseni]

This would have been the usage with new() syntax. But, as mentioned, there is a constraint of C# version, and the consumer's custom collection type should support such constructor (so we're kind of depending on their implementation).

return await _dbContext.Blogs
    .Select(blog => new BlogModel
    {
        Id = blog.Id,
        Name = blog.Name,
        Posts = new(blog.Posts.Select(p => new PostModel
        {
            Id = p.Id,
            Title = p.Title,
        }))
    })
    .ToListAsync();

EF Core supports that, here is the produced SQL query

SELECT [b].[Id], [b].[Name], [p].[Id], [p].[Title]
FROM [Blogs] AS [b]
LEFT JOIN [Post] AS [p] ON [b].[Id] = [p].[BlogId]
ORDER BY [b].[Id]

[fiseni]

If deemed acceptable, I can create a PR with the following change in EnumerableProjectionMapper.

Existing code snippet

if (!memberMap.DestinationType.IsAssignableFrom(sourceExpression.Type))
{
    var convertFunction = memberMap.DestinationType.IsArray ? ToArrayMethod : ToListMethod;
    sourceExpression = Call(convertFunction.MakeGenericMethod(destinationListType), sourceExpression);
}

Proposal:

if (!memberMap.DestinationType.IsAssignableFrom(sourceExpression.Type))
{
    if (memberMap.DestinationType.IsArray)
    {
        sourceExpression = Call(ToArrayMethod.MakeGenericMethod(destinationListType), sourceExpression);
    }
    else if (memberMap.DestinationType.IsAssignableFrom(typeof(List<>).MakeGenericType(destinationListType)))
    {
        sourceExpression = Call(ToListMethod.MakeGenericMethod(destinationListType), sourceExpression);
    }
    else
    {
        var ctorInfo = memberMap.DestinationType.GetConstructor(new[] { typeof(IEnumerable<>).MakeGenericType(destinationListType) });

        if (ctorInfo is null)
        {
            throw new Exception($"The destination collection type '{memberMap.DestinationType.FullName}' should have a constructor with IEnumerable<> parameter.");
        }

        sourceExpression = New(ctorInfo, sourceExpression);
    }
}

[lbargaoanu]

Well, not that code exactly, but smth like that could work :)
You should PR my branch, ahead of master because of integration test changes.

[fiseni]

I do agree it's not ideal, but since I lack familiarity with your internal infrastructure, didn't want to mess with internals. Are the MemberMaps cached? If so, then

• Do you want me to introduce a readonly prop IsAssignableFromList in MemberMap and move the logic there?
• Do you want me to move the ctorInfo there too? Since this is a niche case, and won't be utilized by everyone, do you want me to wrap it in Lazy?

Let me know what am I missing and what are your suggestions, and I'll create a PR to your branch.

[lbargaoanu]

Let's start with an integration test, maybe we can use HashSet<> as the custom collection. I think we can keep the existing code and check whether the Call expression can be assigned to the destination and only if that's not the case, try the new way. But open a PR and we can discuss it there.

[lbargaoanu]

Try the MyGet build.