Extensions.Dictionary 2.7.0

Extensions.Dictionary

Introduction

The easiest way to start using Extensions.Dictionary is to install it’s Nuget package. In Visual Studio open Package Manager console and type the following:

Install-Package Extensions.Dictionary

In the source file where you will be using Dictionary Extensions import the namespace:

using Extensions.Dictionary;

Sample class:

public class Person
{
    [DataMember(Name = "Name1")]
    public string Firstname { get; set; }

    [IgnoreDataMember]
    public string Lastname { get; set; }
}

Convert an instance to a dictionary:

var person = new Person { Firstname = "foo", Lastname = "bar" };

// Option 1: Convert all public properties and instance fields
var dictionary1 = person.ToDictionary(); 

// Option 2: Same as option 1 + respect DataContract attributes (DataMember / IgnoreDataMember)
var settings = new ConverterSettings { Resolver = new DataContractResolver() };
var dictionary2 = person.ToDictionary(settings);

// dictionary1: <Firstname = foo; Lastname = bar>
// dictionary2: <Name1 = foo>

Convert a dictionary back to it's typed instance:

// Option 1
var person1 = dictionary.ToInstance<Person>();

// Option 2
var settings = new ConverterSettings { Resolver = new DataContractResolver() };
var person2 = dictionary.ToInstance<Person>(settings);

Extensibility

Custom MemberConverter

This sample creates a custom converter from MemberConverter<T> that overrides conversion for the System.Numerics.Vector3 class.

public class Vector3Converter : MemberConverter<Vector3>
{
    public override IDictionary<string, object> ToDictionary(Vector3 value, ConverterSettings settings)
    {
        return new Dictionary<string, object>(3)
        {
            { nameof(Vector3.X), value.X },
            { nameof(Vector3.Y), value.Y },
            { nameof(Vector3.Z), value.Z },
        };
    }

    public override Vector3 ToInstance(IDictionary<string, object?> value, ConverterSettings settings)
    {
        return new Vector3
        {
            X = float.Parse(value[nameof(Vector3.X)]?.ToString(), settings.Culture),
            Y = float.Parse(value[nameof(Vector3.Y)]?.ToString(), settings.Culture),
            Z = float.Parse(value[nameof(Vector3.Z)]?.ToString(), settings.Culture),
        };
    }
}

// Usage
var plane = new Plane(1f, 1f, 1f, .1f);

var settings = new ConverterSettings();
settings.Converters.Add(new Vector3Converter());

var dict = plane.ToDictionary(settings);

Custom Resolver

It is possible to customize the member name / value extraction. Just implement the provided ISerializerResolver interface. The following code snipped shows an example of a Json.NET resolver:

public class JsonNetResolver : ISerializerResolver
{
    public string GetMemberName(MemberInfo memberInfo)
    {
        if (memberInfo == null)
        {
            throw new ArgumentNullException(nameof(memberInfo));
        }

        var attribute = memberInfo.GetCustomAttribute<JsonPropertyAttribute>();
        return attribute?.PropertyName ?? memberInfo.Name;
    }

    public object GetMemberValue(MemberInfo memberInfo, object instance)
    {
        switch (memberInfo?.MemberType)
        {
            case MemberTypes.Property:
                return ((PropertyInfo)memberInfo).GetValue(instance);
            case MemberTypes.Field:
                return ((FieldInfo)memberInfo).GetValue(instance);
            case null:
                throw new ArgumentNullException(nameof(memberInfo));
            default:
                throw new NotSupportedException(memberInfo.MemberType + " not supported.");
        }
    }

    public MemberInfo[] GetMemberInfos(Type type)
    {
        return type?
            .GetProperties(BindingFlags.Instance | BindingFlags.Public)
            .Cast<MemberInfo>()
            .Concat(type.GetFields(BindingFlags.Instance | BindingFlags.Public))
            .Where(x => !x.GetCustomAttributes<JsonIgnoreAttribute>().Any())
            ?? Array.Empty<Type>();
    }
}

Benchmarks

The following benchmarks are showing the differences between converting from dictionary to instance and from instance to dictionary. SPOILER: You get the best efficiency with the DefaultResolver.

Test environment

BenchmarkDotNet=v0.12.0, OS=Windows 10.0.18362
Intel Core i7-6700HQ CPU 2.60GHz (Skylake), 1 CPU, 8 logical and 8 physical cores
.NET Core SDK=3.0.100
  [Host]   : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), X64 RyuJIT
  ShortRun : .NET Core 3.0.0 (CoreCLR 4.700.19.46205, CoreFX 4.700.19.46214), X64 RyuJIT 

Convert to dictionary

Convert to instance

Open Source License Acknowledgements and Third-Party Copyrights

• Icon made by Freepik