Map object graph to Dictionary<string, object>

[julkwiec]

Hey guys. I searched through Issues, Discussions, StackOverflow and Google, but I couldn't find anything relevant.

Consider the following example:

class A {
	public int Foo {get;set;}
	public B Bar {get;set;}
}

class B {
	public string Baz {get;set;}
}

void Main()
{
	var mapperConfig = new MapperConfiguration(cfg => { });
	var mapper = mapperConfig.CreateMapper();

	var testSubject = new A { Foo = 5, Bar = new B { Baz = "hello" } };
	var result = mapper.Map<Dictionary<string, object>>(testSubject);
	result.Dump(); // courtesy of LinqPad
}

Here's what AutoMapper returns:

However, what I'm looking for is a recursive mapping of objects to Dictionary<string, object>, like this:

The list of types that I'd like to map this way (A and B in the example above) will be known at compile time, so I could manually configure AutoMapper for each of these types.

I tried several approaches, with just one being moderately successful: I used .AfterMap() to scan through the resulting object's properties using reflection, then manually map the supported types to Dictionary<string, object>. This worked for simple cases, but quickly turned into a pile of hacks when more complex cases were considered, like nested dictionaries or lists of lists:

// For simplicity, let's assume that all types that I want to support this way will implement IMappableToNestedDictionary

public static Dictionary<string, object?> MapObjectToDictionary(this IMapper mapper, IMappableToNestedDictionary obj)
{
	return mapper.Map<Dictionary<string, object?>>(obj, opts => opts.AfterMap((before, after) => MapNestedObjects(mapper, before, after)));
}

private static void MapNestedObjects(IMapper mapper, object before, Dictionary<string, object?> after)
{
	foreach (var (key, value) in after)
	{
		// simple case
		if (value is IMappableToNestedDictionary mappable)
		{
			after[key] = mapper.MapObjectToDictionary(mappable);
		}

		// simple collection case
		else if (value is IEnumerable<IMappableToNestedDictionary> mappableCollection)
		{
			after[key] = mappableCollection.Select(mapper.MapObjectToDictionary).ToList();
		}

		// complex cases like dictionaries, Dictionary<int,List<IMappableToNestedDictionary>>, etc quickly get out of control
		// and turn into a pile of reflection spaghetti
	}
}

Is there a way to make AutoMapper recursively map objects of specified types to Dictionary<string, object> like in the example above without resorting to complex reflection hacks? Basically I want to make AutoMapper automatically map any IMappableToNestedDictionary instance it finds during the mapping process to Dictionary<string, object>.

Should I even be using AutoMapper here, or it's simply not the right tool for this particular use case?

[lbargaoanu]

Maybe it would be easier to serialize to JToken? Because otherwise you would probably need to write a custom object mapper. You would have more control, but I'm not sure you want that :)

[julkwiec]

@lbargaoanu Thank you! JToken proved to be exactly what I was looking for.
Thank you for convincing me not to use AutoMapper ;)