Is it not possible to map from a Dictionary<string, object?>?

[glen-84]

This is possible using AutoMapper.

---

Anything implementing:

IDictionary<string, object>
IDictionary<string, object?>
IReadOnlyDictionary<string, object>
IReadOnlyDictionary<string, object?>

public sealed class Example
{
    public long Id { get; set; }

    public string Name { get; set; }
}

public sealed class ExampleDictionary : IReadOnlyDictionary<string, object?>
{
    // ...
}

[Mapper]
public static partial class ExampleMapper
{
    public static partial Example ExampleDictionaryToExample(ExampleDictionary dictionary);
}

Example example = new ExampleMapper().ExampleDictionaryToExample(new ExampleDictionary()
{
    { "id", 1 }, // Note the difference in character case.
    { "name", "example" }
});

The object value may itself be a dictionary, so it should be recursive.

[TimothyMakkison]

Hey, thanks for the suggestion. Mapperly currently does not support this feature, I've created an issue to add it.

[glen-84]

I think there are a few scenarios:

1. (anything) -> new Dictionary

   In this case, there's no target value/type when mapping to a new dictionary, so it would always copy the values as they are.

2. (anything) -> existing Dictionary

   In this case, the property may exist in the target dictionary, but there is no generic type.

   If the property exists, pass it as the target here, otherwise just use the source value without conversion.

   Something like this might work for some of the conversions:

   static TTarget Convert<TSource, TTarget>(TSource source, TTarget target)
   {
       // From DateTime.
       if (source is DateTime dateTime)
       {
           // To DateOnly.
           if (typeof(TTarget) == typeof(DateOnly))
           {
               return (TTarget)(object)DateOnly.FromDateTime(dateTime);
           }
   
           // To TimeOnly.
           if (typeof(TTarget) == typeof(TimeOnly))
           {
               return (TTarget)(object)TimeOnly.FromDateTime(dateTime);
           }
       }
   
       // From string.
       if (source is string @string)
       {
           // To enum.
           if (typeof(TTarget).IsEnum)
           {
               return (TTarget)Enum.Parse(typeof(TTarget), @string);
           }
   
           // To parsable.
           // Not sure if this is possible without something like:
           // https://github.com/dotnet/csharplang/discussions/6308
       }
   
       // ...
   
       return target;
   }

3. Dictionary -> Object

   In this case, there's a generic target type, but no generic source type.

   static TTarget? Convert<TTarget>(object source)
   {
       // From DateTime.
       if (source is DateTime dateTime)
       {
           // To DateOnly.
           if (typeof(TTarget) == typeof(DateOnly))
           {
               return (TTarget)(object)DateOnly.FromDateTime(dateTime);
           }
   
           // To TimeOnly.
           if (typeof(TTarget) == typeof(TimeOnly))
           {
               return (TTarget)(object)TimeOnly.FromDateTime(dateTime);
           }
       }
   
       // From string.
       if (source is string @string)
       {
           // To enum.
           if (typeof(TTarget).IsEnum)
           {
               return (TTarget)Enum.Parse(typeof(TTarget), @string);
           }
   
           // To parsable.
           // Not sure if this is possible without something like:
           // https://github.com/dotnet/csharplang/discussions/6308
       }
   
       // ...
   
       return default;
   }

I'm not sure how many of the conversions this will support, or how much additional boxing etc. it may cause. Even if automatic conversions were not supported, direct mapping may still be useful.

[glen-84]

Update:

I've decided not to move forward with my current use case for this feature. It could still be a useful feature to have, but I don't have a need for it right now. That may change again in the future. Thanks for your consideration.

[glen-84]

Update 2:

On second thought, I haven't made a final decision regarding the use case that I had in mind*, I'm still trying to determine whether or not it's feasible.

* Mapping a Hot Chocolate GraphQL ObjectResult (which implements IReadOnlyDictionary<string, object?>) to an object graph of entities.

The use case would probably require things like custom mapping for properties with specific names (f.e. map a string key/property named id using special code that decodes the value and extracts a numeric value). I'm not sure if this is possible with Mapperly, especially in a generic way (maybe before/after mapping).

Apologies for the noise/indecisiveness.

[MatthewSteeples]

We're looking at some similar functionality for a similar reason (Azure.Data.Tables) so may end up trying to implement something unless anyone has any objections?

[latonz]

@MatthewSteeples would be happy to see support for this in Mapperly. However, this is not a straight forward task and requires a lot of work.

[latonz]

Closing in favor of #1309.