Ridurre costruttore codice piastra della caldaia

Question

spesso finiscono per scrivere classi come questo:

public class Animal 
{ 
    public string Colour { get; set; } 
    public int Weight { get; set; } 

    public Animal(Dog data) 
    { 
     this.Colour = data.Colour; 
     this.Weight = data.Weight; 
    } 

    public Animal(Cat data) 
    { 
     this.Colour = data.Colour; 
     this.Weight = data.Weight; 
    } 
} 

Quando si dispone di un sacco di proprietà e tipi poi si finisce in fretta con un sacco di codice refusi. Idealmente in questa situazione vorrei solo creare un'interfaccia IAnimal e fare riferimento a questo. Sono attualmente in una situazione in cui le classi Dog e Cat esistono in un assembly di terze parti e non posso modificarle. L'unica soluzione che posso venire in mente è:

public class Animal 
{ 
    public string Colour { get; set; } 
    public int Weight { get; set; } 

    public Animal(Cat data){Init(data);} 
    public Animal(Dog data){Init(data);} 

    private void Init(dynamic data) 
    { 
     this.Colour = data.Colour; 
     this.Weight = data.Weight; 
    } 
} 

Questo funziona, ma ho perso tutta la sicurezza di tipo, c'è una soluzione migliore rispetto a iniezione costruttore?

Grazie,

Joe

EDIT: Ecco un esempio reale mondo. Ho una libreria di terze parti che restituisce 3 oggetti chiamato:

• GetPageByIdResult
• GetPagesByParentIdResult
• GetPagesByDateResult

(Questi vengono generati tutte auto di classi da un riferimento al servizio e le proprietà sono praticamente identico)

Invece di gestire questi tre oggetti, desidero gestire un singolo oggetto PageData o una raccolta di essi.

Answer 1

Si può avere la logica in un costruttore comune che tutti gli altri costruttori chiamano:

public class Animal 
{ 
    public string Colour { get; set; } 
    public int Weight { get; set; } 

    public Animal(Dog data) : this (data.Colour, data.Weight) 
    { 
    } 

    public Animal(Cat data) : this (data.Colour, data.Weight) 
    { 
    } 

    private Animal(string colour, int weight) 
    { 
     this.Colour = colour; 
     this.Weight = weight; 
    } 
} 

Questo è abbastanza simile alla tua seconda soluzione, ma non perde la sicurezza di tipo.

Answer 2

Se non si desidera che la classe sia disseminata in questo modo, è possibile provare i metodi di estensione?

public static Animal ToAnimal(this Dog item) 
{ 
    return new Animal() {Weight = item.Weight, Colour = item.Colour}; 
} 

public static Animal ToAnimal(this Cat item) 
{ 
    return new Animal() {Weight = item.Weight, Colour = item.Colour}; 
} 

Answer 3

Sono attualmente in una situazione in cui esistono le Dog e Cat classi in un assembly di terze parti e non riesco a modificare

Io suggerirei soluzione Automapper-based:

public static class AnimalFactory 
{ 
    public static Animal Create<T>(T source) 
     where T : class 
    { 
     Mapper.CreateMap<T, Animal>(); 
     return Mapper.Map<Animal>(source); 
    } 
} 

Usage:

 var catAnimal = AnimalFactory.Create(cat); 
     var dogAnimal = AnimalFactory.Create(dog); 

Naturalmente, è possibile fornire un modo per configurare il mapping personalizzato, se necessario.

Answer 4

provare a utilizzare json serializer, con ciò possiamo garantire la sicurezza del tipo.

public class Animal 
    { 
     public string Colour { get; set; } 
     public long Weight { get; set; } 
     public string Name { get; set; } 
     public Animal Create<T>(T anyType) 
     { 
      return GetObject<T, Animal>(anyType); 
     } 
     public K GetObject<T, K>(T type1) 
     { 
      try 
      { 
       var serialized = JsonConvert.SerializeObject(type1); 
       return JsonConvert.DeserializeObject<K>(serialized); 
      } 
      catch (Exception ex) 
      { 
       return default(K); 
      } 
     } 
    } 
    class Program 
    { 
     public static void Main(string[] args) 
     { 
      Animal obj = new Animal(); 
      var animal = obj.Create(new { Colour = "Red", Weight = 100 }); 
      //here you can pass any object, only same name properties will be initialized.. 
      Console.WriteLine(animal.Colour + " : " + animal.Weight); 
      Console.ReadKey(); 
     } 
    }