Mapping Collections in Automapper

Question

I'm using Automapper to clone an object. I have a class which contains collections that I want handled in a non-standard way, which I'll explain below (I've stripped out a bunch of code to highlight the specific issue):

public class CommunityModel 
{
    private readonly IUIManaer _uiMgr;
    private readonly IMapper _mapper;

    private ValidatedCollection<CommunityUserModel, string> _users;
    private int _communityIndex = -1;

    public CommunityModel( IUIManager uiMgr, IMapper mapper, IElementManager<CommunityUserModel, string> userMgr )
    {
        _uiMgr = uiMgr ?? throw new NullReferenceException( nameof(uiMgr) );
        _mapper = mapper ?? throw new NullReferenceException( nameof(mapper) );

        Users = new ValidatedCollection<CommunityUserModel, string>( userMgr );

    }

    public int CommunityIndex
    {
        get => _communityIndex;

        set
        {
            if (value < -1) value = -1;

            Set(ref _communityIndex, value);

            IsNew = value < 0;
        }
    }

    public ValidatedCollection<CommunityModel, string> Collection { get; set; }

    public ValidatedCollection<CommunityUserModel, string> Users
    {
        get => _users;

        set
        {
            ChangeTracker.RegisterCollection(value);

            SetAndValidate( ref _users, value );
        }
    }
}

ValidatedCollection<> is an extension of WPF's ObservableCollection. The CommunityIndex property uniquely identifies a CommunityModel instance. This allows me to use the Automapper.Collection extensions via the EqualityComparison() extension method.

I don't want Automapper to initialize the Users collection, because it gets initialized in the class constructor. But I want the elements of the User collection to be cloned from the source Users collection to the destination Users collection.

The Collection collection contains a list of CommunityModel objects, including the instance which has the Collection property (i.e., Collection is a set of sibling CommunityModel instances). I'd like Automapper to initialize the collection, and, ultimately, copy all of the CommunityModel siblings other than the source object to that collection, and then add the destination object to the collection (i.e., in the end, Collection will be a set of sibling CommunityModel objects, with the source CommunityModel replaced by the destination CommunityModel).

My map is currently defined as follows:

CreateMap<CommunityModel, CommunityModel>()
    .ForMember(dest=>dest.Users, opt=>opt.Ignore())
    .ForMember(dest=>dest.Collection, opt=>opt.Ignore()  )
    .EqualityComparison((x,y)=> x.CommunityIndex == y.CommunityIndex);

CreateMap<CommunityUserModel, CommunityUserModel>()
    .EqualityComparison((x,y) => x.UserIndex == y.UserIndex);

If I don't Ignore() the Users collection, Automapper will initialize the collection, which overrides the required configuration of Users set in the constructor and causes problems elsewhere in my app. But if Ignore() the Users collection, its elements are never cloned from source to destination. What I want to do is not have Automapper initialize Users, but still clone the contents.

If I don't ignore the Collection collection, I get an infinite loop and stack overflow, I believe because cloning Collection's elements involves creating an instance of the CommunityModel which owns the Collection property, which should be a reference to the destination object being created, but instead leads to the creation of another identical destination object. What I'd like to do is have Automapper initialize the Collection collection, but >>not<< clone the source elements, which I guess I'd have to do later in an AfterMap() call.

I realize this is somewhat arcane, but the overall design of my project results in these requirements.

What is the best way of doing this within Automapper? Should I look into creating a custom value resolver, even though I'm cloning an object, so the property names are identical between source and destination?

Answer 1

I'm going to describe how I resolved my issue, but I'm not going to mark it as an answer, because I'm not familiar enough with Automapper to know if what I think it's doing is what it's actually doing.

What appears to be happening, when Automapper maps collections -- even with the Automapper.Collections library installed and activated -- is that collections are deemed to be "different", even if the types of the elements in the source and destination collections can be automatically mapped, if the source and destination collection types are different.

For example, if the source Community object has a List<> of CommunityUsers:

public class Community
{
    public string Name { get; set; }
    public string SiteUrl { get; set; }
    public string LoginUrl { get; set; }
    public List<CommunityUser> Users { get; set; }
}

public class CommunityUser
{
    public string UserID { get; set; }
    public string VaultKeyName { get; set; }
}

and you want to map it to destination objects like this:

public class CommunityModel
{
    // omitting constructor, which contains logic to 
    // initialize the Users property based on constructor arguments

    public string Name {get;set;}
    public string LoginUrl {get;set;}
    public string SiteUrl {get;set;}
    public ValidatedCollection<CommunityUserModel, string> Users
    { get; set;}
}

public class CommunityUserModel 
{
    public string UserID {get; set;}
    public string VaultKeyName {get;set;}
}

even though all the property names are "recognizable" by Automapper, and the two Users collections are both IEnumerable, the fact that the two collections are of different types apparently causes Automapper to treat the collections as "different".

And that apparently means the add/delete/copy logic of Automapper.Collections doesn't get used, even if present. Instead, Automapper tries to create an instance of (in this case) ValidatedCollection, populate it from the source object collection, and then assign it to destination object collection.

That's fine if ValidatedCollection<> doesn't have required contructor arguments. But it'll fail if it does. Which is what happened in my case.

My workaround was to do this in the Mapper definition:

CreateMap<Community, CommunityModel>()
    .ForMember(dest=>dest.Users, opt=> opt.Ignore())
    .AfterMap( ( src, dest, rc ) =>
    {
        foreach( var srcUser in src.Users )
        {
            dest.Users.Add(rc.Mapper.Map<CommunityUserModel>(srcUser));
        }
    } );

This keeps Automapper from doing anything with the destination Users property (which is initialized in the CommunityModel constructor), and maps over the source User objects after the "automatic" mapping is done.