How can you instantiate an instance of SomeObject, given the string representation of T?

Question

We have the following class...

public class ValueHolder<T>
{
    public T Value { get; set; }
    public Type ValueType => typeof(T);
}

...which we of course can instantiate like this.

var foo = new ValueHolder<string>() { Value = "Hello World!" };
var laa = new ValueHolder<int>() { Value = 44 };

When we serialize foo and laa using NewtonSoft's Json.NET, we get the following output...

// foo
{
    "Value": "Hello World!",
    "ValueType": "System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
}

// laa
{
    "Value": 44,
    "ValueType": "System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
}

The problem is deserializing it since Json.NET doesn't know it's referring to a generic so it blows up. As such, I need to write a custom converter for this class. However, I'm not sure how to instantiate a new generic instance where the data type used for 'T' in ValueHolder is stored in string-form in ValueType.

More info

I'm actually trying to Serialize/Deserialize a subclass of Dictionary<string,ValueHolder<>> where the T of ValueHolder can be different for every instance (which of course you can't do so I'm actually subclassing Dictionary<string,object> then putting the resolved ValueHolder into 'object') so I think the proper approach is to put the converter on the dictionary and not on ValueHolder itself.

Answer 1

Split you class to be like this:

public class ValueTypeBase
{
    public Type ValueType { get; set; }
}

public class ValueHolder<T> : ValueTypeBase
{
    public T Value { get; set; }
}

And check this code:

var json = "{\"Value\": \"Hello World!\",\"ValueType\": \"System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089\"}";
var valueTypeBase = JsonConvert.DeserializeObject<ValueTypeBase>(json);
var newType = typeof(ValueHolder<>).MakeGenericType(valueTypeBase.ValueType);
var obj = JsonConvert.DeserializeObject(json, newType);

Answer 2

To create new objects from the assembly names, you can use:

Activator.CreateInstance() method. See the documentation here:

https://msdn.microsoft.com/en-us/library/system.activator.createinstance%28v=vs.110%29.aspx

Answer 3

hope this help.

Change ValueHolder class to this:

public class ValueHolder<T>
{
    public ValueHolder() { }
    public ValueHolder(T v)
    {
        Value = v;
    }
    public T Value { get; set; }
    public Type ValueType() { return typeof(T); }
}

then using this code:

        Type d1 = typeof(ValueHolder<>);
        //Your type -> "System.String"
        Type typeArgs = System.Type.GetType("System.String", false, true);
        Type constructed = d1.MakeGenericType(typeArgs);
        //Your Value-> "Test Value"
        var o = Activator.CreateInstance(constructed, "Test Value");    

Answer 4

Reconstructing the value using System.Type.GetType and Type.MakeGenericType is not a problem (kudos to Ali Amanzadegan and Maarten):

var foo = new ValueHolder<string>() { Value = "Hello World!" };
var laa = new ValueHolder<int>() { Value = 44 };
var daa = new ValueHolder<double> { Value = 123.999 };
//
var jsonFoo = JsonConvert.SerializeObject(foo);
var jsonLaa = JsonConvert.SerializeObject(laa);
var jsonDaa = JsonConvert.SerializeObject(daa);
//
Console.WriteLine(String.Format("{0}{3}{1}{3}{2}", jsonFoo, jsonLaa, jsonDaa, Environment.NewLine));
//
var o = JsonConvert.DeserializeObject<JObject>(jsonFoo);
var typeDescription = o.Properties().FirstOrDefault(p => p.Name == "ValueType");
var type = System.Type.GetType(typeDescription.Value.ToString());
var reFoo = (dynamic)JsonConvert.DeserializeObject(jsonFoo, typeof(ValueHolder<>).MakeGenericType(type));
Console.WriteLine(reFoo.Value);

The output:

Hello World!

The difficulty for me was to find a way to extract the functionality in a function/method. One possible solution that I came with was using dynamic again:

private dynamic reconstructValueHolderFromJson(string json)
{
    var o = JsonConvert.DeserializeObject<JObject>(json);
    var typeDescription = o.Properties().FirstOrDefault(p => p.Name == "ValueType");
    var type = System.Type.GetType(typeDescription.Value.ToString());
    return JsonConvert.DeserializeObject(json, typeof(ValueHolder<>).MakeGenericType(type));
}

Now reconstructing the object looks like this (with printing the value):

var reFoo = reconstructValueHolderFromJson(jsonFoo);
Console.WriteLine("{0}", reFoo.Value);

var reLaa = reconstructValueHolderFromJson(jsonLaa);
Console.WriteLine("{0}", reLaa.Value);

var reDaa = reconstructValueHolderFromJson(jsonDaa);
Console.WriteLine("{0}", reDaa.Value);

And the output:

Hello World!
44
123,999