Использование ValueInjecter для сглаживания объектов, включая типы с нулевым значением

Question

Я пытаюсь использовать ValueInjector для выравнивания класса и для его копирования между значениями от Nullable<int>'s до int.

например, данные следующие (придуманные) классов:

class CustomerObject 
{ 
    public int CustomerID { get; set; } 
    public string CustomerName { get; set; } 
    public OrderObject OrderOne { get; set; } 
} 

class OrderObject 
{ 
    public int OrderID { get; set; } 
    public string OrderName { get; set; } 
} 

class CustomerDTO 
{ 
    public int? CustomerID { get; set; } 
    public string CustomerName { get; set; } 
    public int? OrderOneOrderID { get; set; } 
    public string OrderOneOrderName { get; set; } 
} 

Я хотел бы, чтобы расплющить экземпляр CustomerObject к в CustomerDTO, с ним, игнорируя тот факт, что CustomerID и OrderID являются различных типов (один является нулевым, а другой нет).

Так что я хотел бы сделать это:

CustomerObject co = new CustomerObject() { CustomerID = 1, CustomerName = "John Smith" }; 
co.OrderOne = new OrderObject() { OrderID = 2, OrderName = "test order" }; 

CustomerDTO customer = new CustomerDTO(); 
customer.InjectFrom<>(co); 

И затем все свойства заселенных, а именно:

customer.CustomerID 
customer.OrderOneOrderID 
customer.OrderOneOrderName 

Я понимаю, что я могу использовать FlatLoopValueInjection выравниваться объект, и Я использую этот класс NullableInjection:

public class NullableInjection : ConventionInjection 
{ 
    protected override bool Match(ConventionInfo c) 
    { 
     return c.SourceProp.Name == c.TargetProp.Name && 
       (c.SourceProp.Type == c.TargetProp.Type 
       || c.SourceProp.Type == Nullable.GetUnderlyingType(c.TargetProp.Type) 
       || (Nullable.GetUnderlyingType(c.SourceProp.Type) == c.TargetProp.Type 
         && c.SourceProp.Value != null) 
       ); 
    } 

    protected override object SetValue(ConventionInfo c) 
    { 
     return c.SourceProp.Value; 
    } 
} 

В принципе, я бы хотел, чтобы t o объединить эти два. Это возможно?

Answer 1

вы могли бы сделать это путем переопределения метода TypesMatch:

public class MyFlatInj : FlatLoopValueInjection 
    { 
     protected override bool TypesMatch(Type sourceType, Type targetType) 
     { 
      var snt = Nullable.GetUnderlyingType(sourceType); 
      var tnt = Nullable.GetUnderlyingType(targetType); 

      return sourceType == targetType 
        || sourceType == tnt 
        || targetType == snt 
        || snt == tnt; 
     } 
    } 

или путем захвата FlatLoopValueInjection из исходного кода и изменить его, как вам нужно (это около 10 строк)

Answer 2

// !!! THIS IS FOR LoopInjection not FlatLoopValueInjection !!! 
public class NullableInjection : LoopInjection 
{ 
    public NullableInjection() : base() { } 

    public NullableInjection(string[] ignoredProps) : base(ignoredProps) { } 

    protected override bool MatchTypes(Type source, Type target) 
    { 
     // This is the most likely scenario test for it first. 
     bool result = source == target; 
     // if not a type match then lets do more expensive tests. 
     if (!result) 
     { 
      var snt = Nullable.GetUnderlyingType(source); 
      var tnt = Nullable.GetUnderlyingType(target); 

      // Make sure that underlying types have not reverted to null  
      // this will cause false positives. 
      result = ((source == target) 
        || ((tnt != null) && source == tnt) 
        || ((snt != null) && target == snt) 
        || ((tnt != null) && snt == tnt)); 
     } 
     return result; 
    } 
}