omega.valueinjecter deep clone w przeciwieństwie do typów

Question

Myślę, że brakuje mi prostej koncepcji z valueinjecter i/lub AutoMapper, ale jak głęboko klonować rodzica dto.Entity to biz.Entity i uwzględnić wszystkie dzieci? Na przykład: biz.person.InjectFrom(dto.person). Chcę, aby kolekcja dto.person.AddressList była kopiowana do kolekcji biz.person.AddressList, mimo że dto.Address i biz.Address są różne od typów, ale mają te same nazwy właściwości.

Uważam, że jeśli nazwy właściwości nadrzędnych są pisane tak samo, np. AddressList, wtedy nie ma znaczenia, czy dwa obiekty leżące u podstaw są różnych typów. Byłoby jeszcze kopiować samych nazwach typów prostych jak int, string itp

dziękuję

Answer 1

miałem ten sam problem, gdy macierze/wykazy w obiektach mają takie same nazwy, ale różne typy (czyli właściwość o nazwie Zwierzęta typu ORMAnimals [] mapująca do właściwości o nazwie Zwierzęta typu Zwierzęta []).

z niewielkimi szczypie w kodzie próbki Chuck Norris ma na Deep Klonowanie page mam to działa w moim kodu testu:

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

    protected override object SetValue(ConventionInfo c) 
    { 
     //for value types and string just return the value as is 
     if (c.SourceProp.Type.IsValueType || c.SourceProp.Type == typeof(string) 
      || c.TargetProp.Type.IsValueType || c.TargetProp.Type == typeof(string)) 
      return c.SourceProp.Value; 

     //handle arrays 
     if (c.SourceProp.Type.IsArray) 
     { 
      var arr = c.SourceProp.Value as Array; 
      var clone = Activator.CreateInstance(c.TargetProp.Type, arr.Length) as Array; 

      for (int index = 0; index < arr.Length; index++) 
      { 
       var a = arr.GetValue(index); 
       if (a.GetType().IsValueType || a.GetType() == typeof(string)) continue; 
       clone.SetValue(Activator.CreateInstance(c.TargetProp.Type.GetElementType()).InjectFrom<CloneInjection>(a), index); 
      } 
      return clone; 
     } 


     if (c.SourceProp.Type.IsGenericType) 
     { 
      //handle IEnumerable<> also ICollection<> IList<> List<> 
      if (c.SourceProp.Type.GetGenericTypeDefinition().GetInterfaces().Contains(typeof(IEnumerable))) 
      { 
       var t = c.TargetProp.Type.GetGenericArguments()[0]; 
       if (t.IsValueType || t == typeof(string)) return c.SourceProp.Value; 

       var tlist = typeof(List<>).MakeGenericType(t); 
       var list = Activator.CreateInstance(tlist); 

       var addMethod = tlist.GetMethod("Add"); 
       foreach (var o in c.SourceProp.Value as IEnumerable) 
       { 
        var e = Activator.CreateInstance(t).InjectFrom<CloneInjection>(o); 
        addMethod.Invoke(list, new[] { e }); // in 4.0 you can use dynamic and just do list.Add(e); 
       } 
       return list; 
      } 

      //unhandled generic type, you could also return null or throw 
      return c.SourceProp.Value; 
     } 

     //for simple object types create a new instace and apply the clone injection on it 
     return Activator.CreateInstance(c.TargetProp.Type) 
      .InjectFrom<CloneInjection>(c.SourceProp.Value); 
    } 
}