Clone de la classe dérivée de la classe de base de la méthode

Vous pouvez ajouter un constructeur de copie pour votre classe de base:

public abstract Base
{
protected int field1;
protected int field2;
protected Base() { ... }
protected Base(Base copyThis) : this()
{ 
this.field1 = copyThis.field1;
this.field2 = copyThis.field2;
}
public abstract Base Clone();
}
public Child1 : Base
{
protected int field3;
public Child1 () : base() { ... }
protected Child1 (Child1  copyThis) : base(copyThis)
{
this.field3 = copyThis.field3;
}
public override Base Clone() { return new Child1(this); }
}
public Child2 : Base
{
public Child2 () : base() { ... }
protected Child (Child  copyThis) : base(copyThis)
{  }
public override Base Clone() { return new Child2(this); }
}
public Child3 : Base
{
protected int field4;
public Child3 () : base() { ... }
protected Child3 (Child3  copyThis) : base(copyThis)
{
this.field4 = copyThis.field4;
}
public override Base Clone()
{
var result = new Child1(this);
result.field1 = result.field2 - result.field1;
}
}

J'ai fait quelque chose de similaire comme Alexandre Simonov, mais peut-être plus simple. L'idée est (comme je l'ai dit dans un commentaire) pour avoir juste un Clone() dans la classe de base et de laisser tout le travail virtuel CloneImpl() qui chaque classe définit en tant que de besoin, en s'appuyant sur la CloneImpl()s des classes de base.

Création d'un type approprié est laissé de C# MemberwiseClone() qui va faire ce qu'il faut pour l'objet qui appelle. Cela permet également d'éviter la nécessité d'un constructeur par défaut dans toutes les classes (aucun n'est jamais appelé).

using System;
namespace CloneImplDemo
{
//dummy data class
class DeepDataT : ICloneable 
{
public int i;
public object Clone() { return MemberwiseClone(); } 
}
class Base: ICloneable
{
protected virtual Base CloneImpl()
{ 
//Neat: Creates the type of whatever object is calling. 
//Also obviates the need for default constructors
//(Neither Derived1T nor Derived2T have one.)
return (Base)MemberwiseClone();
}
public object Clone() 
{
//Calls whatever CloneImpl the  
//actual calling type implements.
return CloneImpl();
}
}
//Note: No Clone() re-implementation
class Derived1T : Base
{
public Derived1T(int i) { der1Data.i = i; }
public DeepDataT der1Data = new DeepDataT();
protected override Base CloneImpl()
{
Derived1T cloned = (Derived1T)base.CloneImpl();
cloned.der1Data = (DeepDataT)der1Data.Clone();
return cloned;
}
}
//Note: No Clone() re-implementation.
class Derived2T : Derived1T
{
public Derived2T(int i1, int i2) : base(i1)
{
der2Data.i = i2;
}
public string txt = string.Empty; //copied by MemberwiseClone()
public DeepDataT der2Data = new DeepDataT();
protected override Base CloneImpl()
{
Derived2T cloned = (Derived2T)base.CloneImpl();
//base members have been taken care of in the base impl.
//we only add our own stuff.
cloned.der2Data = (DeepDataT)der2Data.Clone();
return cloned;
}
}
class Program
{
static void Main(string[] args)
{
var obj1 = new Derived2T(1,2);
obj1.txt = "this is obj1";
var obj2 = (Derived2T)obj1.Clone();
obj2.der1Data.i++;
obj2.der2Data.i++; //changes value.
obj2.txt = "this is a deep copy"; //replaces reference.
//the values for i should differ because 
//we performed a deep copy of the DeepDataT members.
Console.WriteLine("obj1 txt, i1, i2: " + obj1.txt + ", " + obj1.der1Data.i + ", " + obj1.der2Data.i);
Console.WriteLine("obj2 txt, i1, i2: " + obj2.txt + ", " + obj2.der1Data.i + ", " + obj2.der2Data.i);
}
}
}

De sortie:

obj1 txt, i1, i2: this is obj1, 1, 2
obj2 txt, i1, i2: this is a deep copy, 2, 3

Si la performance n'est pas important pour votre cas, vous pouvez simplifier votre code en créant simplement une méthode clone qui peut cloner que ce soit pour quoi que si les propriétés sont les mêmes:

Base base = new Base(){...};
Derived derived = XmlClone.CloneToDerived<Base, Derived>(base);
public static class XmlClone
{
public static D CloneToDerived<T, D>(T pattern)
where T : class
{
using (var ms = new MemoryStream())
{
using (XmlWriter writer = XmlWriter.Create(ms))
{
Type typePattern = typeof(T);
Type typeTarget = typeof(D);
XmlSerializer xmlSerializerIn = new XmlSerializer(typePattern);
xmlSerializerIn.Serialize(writer, pattern);
ms.Position = 0;
XmlSerializer xmlSerializerOut = new XmlSerializer(typeTarget, new XmlRootAttribute(typePattern.Name));
D copy = (D)xmlSerializerOut.Deserialize(ms);                    
return copy;
}
}
}
}