omu.valueinjecter deep clone a differenza dei tipi

Question

Penso che mi manchi un concetto semplice con valueinjecter e/o AutoMapper, ma come si fa a clonare in profondità un genitore dto.Entity in biz.Entity e includere tutti i bambini?

Ad esempio, biz.person.InjectFrom(dto.person). Desidero che la raccolta dto.person.AddressList venga copiata nella raccolta biz.person.AddressList, anche se dto.Address e biz.Address sono diversi dai tipi, ma hanno gli stessi nomi di proprietà.

Il mio pensiero è che se i nomi di proprietà Parent sono scritti lo stesso, ad es. AddressList, quindi non avrebbe importanza se i 2 oggetti sottostanti fossero di diverso tipo. Sarebbe comunque copiare tipi semplici omonima come int, string, ecc

grazie

Answer 1

ho avuto lo stesso problema quando le matrici/elenchi gli oggetti hanno gli stessi nomi, ma diversi tipi (vale a dire un proprietà denominata Animali di tipo ORMAnimals [] mappatura a una proprietà denominata Animali di tipo Animali []).

con alcune modifiche minori al codice di esempio Chuck Norris ha sulla profonda Clonazione page ho preso a lavorare nel mio codice di prova:

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); 
    } 
}