Unboxing typy nullable - obejście?

Question

mam przechowywania operację aktualizacji w następujący sposób:

class Update 
{ 
    public Expression MemberExpression { get; set; } 
    public Type FieldType { get; set; } 
    public object NewValue { get; set; } 
} 

Na przykład:

var myUpdate = new Update 
{ 
    MemberExpression = (MyType o) => o.LastModified, 
    FieldType = typeof(DateTime?), 
    NewValue = (DateTime?)DateTime.Now 
} 

Wtedy staram się zastosować tę aktualizację później (uproszczony):

var lambda = myUpdate.MemberExpression as LambdaExpression; 
var memberExpr = lambda.Body as MemberExpression; 
var prop = memberExpr.Member as PropertyInfo; 
prop.SetValue(item, myUpdate.Value); 

Jednak myUpdate.Value to DateTime, a nie DateTime?. Dzieje się tak dlatego, że po rzuceniu wartości zerowej do object, staje się ona null lub powoduje skrzynie typu wartości.

Od (DateTime?)myUpdate.Value będzie działać, aby przywrócić go do prawidłowego typu, próbowałem symulować ten konstrukt kompilacji przy użyciu Convert.ChangeType. Jednak mówi, że odlewanie z DateTime do DateTime? nie jest możliwe.

Jakie podejście można zastosować, aby przywrócić obiekt do pierwotnego typu?

Czy istnieje sposób na przechowywanie typów zerowanych, regularnych struktur i zwykłych obiektów w jednym polu, i uzyskać dokładną rzecz do niego ponownie?

Answer 1

Jeśli znasz typ swojego wyrażenia podczas tworzenia myUpdate, SetInfo() odpowiednio ustawi twoje dane, nawet jeśli boks/rozpakowanie.

public class Update 
{ 
    public Expression MemberExpression { get; set; } 
    public Type ClassType { get; set; } 
    public object NewValue { get; set; } 
} 

public class MyType 
{ 
    public DateTime? LastModified { get; set; } 
} 

void Main() 
{ 
    var myUpdate = new Update 
    { 
     MemberExpression = 
      (Expression<Func<MyType, DateTime?>>)((MyType o) => o.LastModified), 
     ClassType = typeof(MyType), 
     NewValue = DateTime.Now 
    }; 

    // At a later point where we do not want to instantiate via strong typing 
    var item = Activator.CreateInstance(myUpdate.ClassType); 

    var lambda = myUpdate.MemberExpression as LambdaExpression; 
    var memberExpr = lambda.Body as MemberExpression; 
    var prop = memberExpr.Member as PropertyInfo; 

    prop.SetValue(item, myUpdate.NewValue); 

    item.Dump(); 
} 

To poprawnie wyprowadza wartość DateTime odpowiadającą temu, kiedy została utworzona bez wyjątku.

Answer 2

Może możesz użyć ogólnej klasy?

class Update<TField> 
{ 
    public Expression<Func<MyType, TField>> MemberExpression { get; set; } 
    public TField NewValue { get; set; } 
} 

Nie jestem pewien, czy można po prostu użyć zwykłego Func<MyType, TField> delegata zamiast drzewa ekspresji, do użytku.

Answer 3

udało mi się rozwiązać za pomocą wyrażeń i bez refleksji TOO:

 var lambda = update.MemberExpression as LambdaExpression; 
     var memberExpr = lambda.Body as MemberExpression; 
     if (memberExpr == null) 
     { 
      throw new NotSupportedException("Field expression must be a member expression"); 
     } 

     // do a cast - this ensures nullable types work, for instance 
     var cast = Expression.Convert(Expression.Constant(update.Value), update.FieldType); 

     // assign the target member with the cast value 
     var assignment = Expression.Assign(memberExpr, cast); 

     // build a new lambda, no return type, which does the assignment 
     var newLambda = Expression.Lambda(typeof(Action<T>), assignment, lambda.Parameters[0]); 

     // compile to something we can invoke, and invoke 
     var compiled = (Action<T>)newLambda.Compile(); 

     compiled(item); 

i voila, przedmiot jest modyfikowany :)