Come “clonare” un oggetto in un oggetto sottoclasse?
Domanda
Ho un A
classe e una classe che eredita B
classe A
e si estende con alcuni più campi.
Avere un oggetto di tipo a
A
, come posso creare un oggetto di tipo b
B
che contiene tutti i dati che si oppongono a
contenute?
Ho provato a.MemberwiseClone()
ma che mi dà solo un altro oggetto di tipo A
. E non posso lanciare A
in B
dal momento che la relazione di ereditarietà consente solo il cast opposto.
Qual è il modo giusto per fare questo?
Soluzione
Non v'è alcun modo per farlo automaticamente incorporato nella lingua ...
Una possibilità è quella di aggiungere un costruttore per la classe B che prende una classe A come argomento.
Poi si potrebbe fare:
B newB = new B(myA);
Il costruttore può semplicemente copiare i dati rilevanti attraverso, se necessario, in questo caso.
Altri suggerimenti
Vorrei aggiungere un costruttore di copia ad A, e quindi aggiungere un nuovo costruttore per B che prende un'istanza di A e lo passa al costruttore di copia della base.
È possibile raggiungere questo obiettivo utilizzando riflessione.
Vantaggio: Maintainability. Non c'è bisogno di cambiare costruttore di copia o simile, aggiungendo o rimuovendo le proprietà.
Svantaggi : Performance. Riflessione è lento. Stiamo ancora parlando millisecondi sulle classi medie dimensioni però.
Ecco un'implementazione copia superficiale riflessione a base di supporto copy-to-sottoclasse, utilizzando metodi di estensione:
public static TOut GetShallowCopyByReflection<TOut>(this Object objIn)
{
Type inputType = objIn.GetType();
Type outputType = typeof(TOut);
if (!outputType.Equals(inputType) && !outputType.IsSubclassOf(inputType)) throw new ArgumentException(String.Format("{0} is not a sublcass of {1}", outputType, inputType));
PropertyInfo[] properties = inputType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
FieldInfo[] fields = inputType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
TOut objOut = (TOut)Activator.CreateInstance(typeof(TOut));
foreach (PropertyInfo property in properties)
{
try
{
property.SetValue(objIn, property.GetValue(objIn, null), null);
}
catch (ArgumentException) { } // For Get-only-properties
}
foreach (FieldInfo field in fields)
{
field.SetValue(objOut, field.GetValue(objIn));
}
return objOut;
}
Questo metodo copia tutte le proprietà - pubblici e privati, così come tutti i campi. Le proprietà sono copiati per riferimento, che lo rende una copia.
Prove di unità:
[TestClass]
public class ExtensionTests {
[TestMethod]
public void GetShallowCloneByReflection_PropsAndFields()
{
var uri = new Uri("http://www.stackoverflow.com");
var source = new TestClassParent();
source.SomePublicString = "Pu";
source.SomePrivateString = "Pr";
source.SomeInternalString = "I";
source.SomeIntField = 6;
source.SomeList = new List<Uri>() { uri };
var dest = source.GetShallowCopyByReflection<TestClassChild>();
Assert.AreEqual("Pu", dest.SomePublicString);
Assert.AreEqual("Pr", dest.SomePrivateString);
Assert.AreEqual("I", dest.SomeInternalString);
Assert.AreEqual(6, dest.SomeIntField);
Assert.AreSame(source.SomeList, dest.SomeList);
Assert.AreSame(uri, dest.SomeList[0]);
}
}
internal class TestClassParent
{
public String SomePublicString { get; set; }
internal String SomeInternalString { get; set; }
internal String SomePrivateString { get; set; }
public String SomeGetOnlyString { get { return "Get"; } }
internal List<Uri> SomeList { get; set; }
internal int SomeIntField;
}
internal class TestClassChild : TestClassParent {}
private abstract class A
{
public int P1 { get; set; }
public abstract A CreateInstance();
public virtual A Clone()
{
var instance = CreateInstance();
instance.P1 = this.P1;
return instance;
}
}
private class B : A
{
public int P2 { get; set; }
public override A CreateInstance()
{
return new B();
}
public override A Clone()
{
var result = (B) base.Clone();
result.P2 = P2;
return result;
}
}
private static void Main(string[] args)
{
var b = new B() { P1 = 111, P2 = 222 };
var c = b.Clone();
}
Creare un ctor in B che permette di passare in un oggetto di tipo A, quindi copiare i campi A e impostare i campi B, come appropriato.
Si potrebbe fare un metodo Converti in classe B che prende nella classe base.
public ClassB Convert(ClassA a)
{
ClassB b = new ClassB();
// Set the properties
return b;
}
Si potrebbe anche avere un costruttore per ClassB prendere in un oggetto di ClassA.
No, non puoi farlo. Un modo per raggiungere questo obiettivo è quello di aggiungere un costruttore in classe B che accetta un parametro di tipo B, e aggiungere manualmente i dati.
Quindi, si potrebbe avere qualcosa di simile:
public class B
{
public B(A a)
{
this.Foo = a.foo;
this.Bar = a.bar;
// add some B-specific data here
}
}
Nella vostra classe di base aggiungere il metodo virtuale CreateObject qui sotto ...
public virtual T CreateObject<T>()
{
if (typeof(T).IsSubclassOf(this.GetType()))
{
throw new InvalidCastException(this.GetType().ToString() + " does not inherit from " + typeof(T).ToString());
}
T ret = System.Activator.CreateInstance<T>();
PropertyInfo[] propTo = ret.GetType().GetProperties();
PropertyInfo[] propFrom = this.GetType().GetProperties();
// for each property check whether this data item has an equivalent property
// and copy over the property values as neccesary.
foreach (PropertyInfo propT in propTo)
{
foreach (PropertyInfo propF in propFrom)
{
if (propT.Name == propF.Name)
{
propF.SetValue(ret,propF.GetValue(this));
break;
}
}
}
return ret;
}
poi dire che si desidera creare un oggetto sottoclasse di vita reale dalla classe Super basta chiamare
this.CreateObject<subclass>();
Che dovrebbe farlo!
Anche se nessuno ha suggerito questo (e questo non funziona per tutti, è vero), va detto che se avete la possibilità di creare l'oggetto B dal get-go, non che invece di creare un oggetto poi copiare di opporsi b. Per esempio, immaginate di essere nella stessa funzione e hanno questo codice:
var a = new A();
a.prop1 = "value";
a.prop2 = "value";
...
// now you need a B object instance...
var b = new B();
// now you need to copy a into b...
Invece di preoccuparsi di quell'ultimo passo commentato, basta iniziare con B e impostare i valori:
var b = new B();
b.prop1 = "value";
b.prop2 = "value";
Si prega di non downvote me perché pensi che quanto sopra è stupido! Ho incontrato molti programmatori che sono così concentrati sul loro codice che non si rendevano conto una soluzione più semplice li sta fissando in faccia. :)