Activator.CreateInstance和Convert.ChangeType的空问题

Question

I have a third party library which sets a given objects property using reflection as follows. (This is the simplified version)

public void Set(object obj, string prop, object value) {
    var propInf = obj.GetType().GetProperty(prop);
    value = Convert.ChangeType(value, propInf.PropertyType);
    propInf.SetValue(obj, value, null);
}

And We have class with a nullable property

class Test
{
    public int? X { get; set; }
}

When I write the following code, it says it cannot convert int to int?

var t = new Test();
Set(t, "X", 1);

Since Nullable does not implement IConvertible it makes sense. Then I decided to write a method which returns the nullable version of a given value typed object.

public object MakeNullable(object obj) {
    if(obj == null || !obj.GetType().IsValueType)
        throw new Exception("obj must be value type!");

    return Activator.CreateInstance(
        typeof(Nullable<>).MakeGenericType(obj.GetType()), 
        new[] { obj });
}

I hoped to use this method as follows.

var t = new Test();
Set(t, "X", MakeNullable(1));

But it still says it cannot convert int to int? . When I debug typeof(Nullable<>).MakeGenericType(obj.GetType()) equals int? but Activator.CreateInstace returns an int value not int?

So this is my case... Any help?

Answer 1

Try this code...

public void Set(object obj, string prop, object value)
      {
          //var propInf = obj.GetType().GetProperty(prop);
          //value = Convert.ChangeType(value, propInf.PropertyType);
          //propInf.SetValue(obj, value, null);
          var property = obj.GetType().GetProperty(prop);
          if (property != null)
          {
              Type t = Nullable.GetUnderlyingType(property.PropertyType)
                           ?? property.PropertyType;

              object safeValue = (value == null) ? null
                                                 : Convert.ChangeType(value, t);

              property.SetValue(obj, safeValue, null);
          }
      }

from here Convert.ChangeType() fails on Nullable Types by LukeH

UPDATE : Hide base method.

namespace ConsoleApplication2
{
using System;
using System.Collections.Generic;
using System.Linq;

internal class Program
{
    private static void Main(string[] args)
    {
        EnterPoint t = new EnterPoint();
        t.BeginProcess();
    }
}

public class EnterPoint
{
    public void BeginProcess()
    {
        var t = new Test(); //Object

        try
        {
            baseDllMethod m = new baseDllMethod(); //Your DLL
            m.Set(t, "X", 1); //Problem Method, this give you error
        }
        catch (Exception ex)
        {
            Console.WriteLine("ERROR EN DLL METHOD");    
        }


        xyz_D der = new xyz_D(); //Derivated method
        der.Set(t, "X", 1) ; //HIDE BASE METHOD
    }
}

public class baseDllMethod //YOUR DLL HERE
{
    public void Set(object obj, string prop, object value)
    {
        var propInf = obj.GetType().GetProperty(prop);
        value = Convert.ChangeType(value, propInf.PropertyType);
        propInf.SetValue(obj, value, null);
    }
}

public class xyz_D : baseDllMethod //Inherits
{
    public new void Set(object obj, string prop, object value) //Hide base method
    {
        var property = obj.GetType().GetProperty(prop);
        if (property != null)
        {
            Type t = Nullable.GetUnderlyingType(property.PropertyType)
                         ?? property.PropertyType;

            object safeValue = (value == null) ? null
                                               : Convert.ChangeType(value, t);

            property.SetValue(obj, safeValue, null);
        }
    }
}

public class Test //Your Object
{
    public int? X { get; set; }
}

}

Answer 2

This should work:

public static object ChangeType(object value, Type conversionType)
{
   if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition() == typeof(Nullable<>))
   {
       if (value == null)
           return null;
       var nullableConverter = new NullableConverter(conversionType);
       conversionType = nullableConverter.UnderlyingType;
    }
    return Convert.ChangeType(value, conversionType);
 }