How to map from Dictionary<string, object> to Class Case-Insensitive?

[drmcclelland]

Using AutoMapper 9 with a .NET Core 2.2 console app, I have replicated an issue we have with case-sensitivity when mapping from a Dictionary<string, object> to a C# class.

Per the docs, you can map straight from Dictionary<string, object> to objects, AutoMapper will line up the keys with property names.

However, this seems to be case-sensitive, because in my example below, the dictionary key "ID" is not being mapped to the property name "Id".

What configuration do I need to make this mapping to be case-insensitive?

    class Program
    {
        public class Person
        {
            public int Id { get; set; }
            public string Name { get; set; }
        }

        static void Main(string[] args)
        {
            var config = new MapperConfiguration(cfg => {});

            var mapper = config.CreateMapper();

            var good = new Dictionary<string, object>
            {
                {"Id", 123 },
                {"Name", "John Doe" },
            };

            var bad = new Dictionary<string, object>
            {
                {"ID", 456 },
                {"Name", "Jane Doe" },
            };

            var personGood = mapper.Map<Person>(good);
            var personBad = mapper.Map<Person>(bad);

            Debug.Assert(personGood.Id == 123);
            Debug.Assert(personGood.Name == "John Doe");

            Debug.Assert(personBad.Id == 456);    // This assertion fails since personBad.Id == 0
            Debug.Assert(personBad.Name == "Jane Doe");
        }
    }

[lbargaoanu]

That's not possible. You'll have to do the conversion yourself. If you're interested in implementing this in AM, we can discuss it.

[lbargaoanu]

@jbogard I think we can say this is a bug (I have no idea how to configure case sensitive mapping in the typed case) and, breaking change aside, switch to case insensitive matching.

[jbogard]

I think the problem is that dictionary and dynamic mapping don't honor much of any of the configuration. It's a completely separate mapper with its own rules, kinda like the DataReader mapper.

I think it might be worth investigating breaking this mapper out like we did with DataReader so that it's explicit that these rules are different.

[lbargaoanu]

I see your point, but I don't think moving things would help much. These are widely used types and I think they belong here. It's true that we don't plan to integrate them better with the rest of AM. But they are still useful. The regular mapping is case insensitive and this should be too.

[drmcclelland]

The case-sensitive matching seems to be in FromStringDictionaryMapper:

var members = from name in source.Keys
              join member in destTypeDetails.PublicWriteAccessors on name equals member.Name
              select member;

I was able to create my own case-insensitive version of this mapper, and force it to be inserted at the beginning of the list of mappers so it comes before the built-in FromStringDictionaryMapper:

var config = new MapperConfiguration(cfg =>
{
    cfg.Mappers.Insert(0, new CaseInsensitiveFromStringDictionaryMapper());
});

Is this a "legit" way to workaround the case-sensitivity issue? 😄

Here's the code for my CaseInsensitiveFromStringDictionaryMapper:

class CaseInsensitiveFromStringDictionaryMapper : IObjectMapper
{
	private static readonly MethodInfo MapMethodInfo =
		typeof(CaseInsensitiveFromStringDictionaryMapper).GetTypeInfo().GetDeclaredMethod(nameof(Map));

	public bool IsMatch(TypePair context) => typeof(StringDictionary).IsAssignableFrom(context.SourceType);

	public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
		IMemberMap memberMap, Expression sourceExpression, Expression destExpression,
		Expression contextExpression) =>
		Call(null,
			MapMethodInfo.MakeGenericMethod(destExpression.Type),
			sourceExpression,
			Condition(
				Equal(ToObject(destExpression), Constant(null)),
				DelegateFactory.GenerateConstructorExpression(destExpression.Type),
				destExpression),
			contextExpression,
			Constant(profileMap));

	private static TDestination Map<TDestination>(StringDictionary source, TDestination destination, ResolutionContext context, ProfileMap profileMap)
	{
		var destTypeDetails = profileMap.CreateTypeDetails(typeof(TDestination));

		// "Case insensitivity" implemented by explicitly stating the type of IEqualityComparer to be used by Join().
		var members = source.Keys.Join(
			destTypeDetails.PublicWriteAccessors,
			name => name,
			member => member.Name,
			(dictionaryKey, member) => (dictionaryKey, member),
			StringComparer.OrdinalIgnoreCase);

		object boxedDestination = destination;
		foreach (var (dictionaryKey, member) in members)
		{
			var value = context.MapMember(member, source[dictionaryKey], boxedDestination);
			member.SetMemberValue(boxedDestination, value);
		}
		return (TDestination)boxedDestination;
	}
}

NOTE: since AutoMapper.ReflectionExtensions is marked as "internal" I also had to copy that class into my project in order to compile my CaseInsensitiveFromStringDictionaryMapper.

[lock]

This thread has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.