Erstellen eines geklonten Kopie Unterklasse von baseclass

Hier ist eine Möglichkeit (von vielen Möglichkeiten), dass Sie etwas tun können, wie Sie gefragt haben. Ich bin mir nicht sicher, das ist sehr hübsch und kann sein Art hässlich zu Debuggen, aber ich denke, es funktioniert:

class BaseClass
{
    public int i { get; set; }

    public BaseClass Clone(BaseClass b)
    {
        BaseClass clone = new BaseClass();
        clone.i = b.i;
        return clone;
    }

}

class SubClass : BaseClass
{
    public int j { get; set; }

    public void foo() { Console.WriteLine("in SubClass with value of i = {0}", i.ToString()); }
}

class Program
{
    static void Main(string[] args)
    {
        BaseClass b1 = new BaseClass() { i = 17 };
        BaseClass b2 = new BaseClass() { i = 35 };

        SubClass sub1 = CloneAndUpcast<SubClass>(b1);
        SubClass sub2 = CloneAndUpcast<SubClass>(b2);

        sub1.foo();
        sub2.foo();
    }

    static T CloneAndUpcast<T>(BaseClass b) where T : BaseClass, new()
    {
        T clone = new T();

        var members = b.GetType().GetMembers(BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance);
        for (int i = 0; i < members.Length; i++)
        {
            if (members[i].MemberType== MemberTypes.Property)
            {
                clone
                    .GetType()
                    .GetProperty(members[i].Name)
                    .SetValue(clone, b.GetType().GetProperty(members[i].Name).GetValue(b, null), null);
            }

        }
        return clone;
    }
}

Im Grunde, wie Sie vorgeschlagen, Sie verwenden Sie reflektion, um zu Durchlaufen und die Eigenschaften des Objekts (ich i und j als öffentliche Eigenschaften) und setzen Sie die Werte entsprechend in das geklonte Objekt. Der Schlüssel ist die Verwendung von Generika zu sagen, CloneAndUpcast welche Art Sie es zu tun haben. Sobald Sie das tun, ist es ziemlich einfach.

Hoffe, das hilft. Viel Glück!

Pro die "Gang of Four" : "Favor composition over inheritance" und dies ist ein perfekter Grund, so zu tun...

Wenn wir eine Oberklasse, die wie folgt aussieht:

public class SuperClass : Person 

Der Oberklasse können ganz einfach dekorieren die Klasse "Person" hinzufügen von Eigenschaften, die nicht in Person-Klasse.
Aber was passiert, wenn der Superklasse Dekorationen sind nur für die GUI? Zum Beispiel ein boolescher Wert, der angibt, "Ausgewählt". Wir sind noch in der Lage zu erhalten, alle Personen aus der DB in eine Liste, sondern wir führen Sie in Schwierigkeiten, die versuchen, um die Oberklasse, und führen Sie die DB-Ergebnisse.

    foreach( var person in myPersonList){
    var sc = new SuperClass();
    sc.Selected = false;
    sc=person;
 }

Der compiler meckert, weil die Oberklasse ist nicht eine Person, die für den compiler ist es ein Superklasse. Der einzige Weg, um füllen Sie die Eigenschaften der Person, die Unterklasse wird zu iterieren und jeweils einer an... so wie hier.

    SuperClass.Name = Person.Name;
    SuperClass.Id = Person.ID;  

Ziemlich langweilig in der Tat. Aber es gibt einen besseren Weg.... Machen Sie nicht Superklasse Erben von Person

public class SuperClass{
  public Person ThisPerson {get;set;}
  public bool Selected {get;set;}
}

Dies gibt uns die "Containment" - Die Oberklasse enthält jetzt eine Klasse "Person".

Jetzt können wir dies tun:

foreach(var person in MyPersonList){
   var sc = new Superclass();
   sc.Selected = false;
   sc.Person = person;
}

Den Verbraucher von dieser Klasse muss jetzt qualifizieren die Eigenschaften der Oberklasse/Person...

forach(var sc in MySuperClassList){
  var selected = sc.Selected;
  var name = sc.Person.Name;
}

Die Schönheit dieser ist, dass in der Zukunft, können Sie jede beliebige andere container, die Sie wollen, und es wird KEINE Auswirkungen auf andere Container. Sie können auch morph der Superklasse-alles, was es enthält. Wenn jedes der enthaltenen Klassen werden zu Schnittstellen, dann ist das ein Schritt weiter die Straße hinunter.

Klon ist eine schlechte Praxis, und Ihre Frage ist der Grund für das (Unterklasse Klonen).
In der Regel sollten Sie nur verwenden, kopieren cotrs statt und haben die Unterklasse akzeptieren ein Elternteil als parameter.

public Base(){}

public Base(Base pSource){}

public Sub(){}

public Sub(Base pSource, weitere Parameter...){}

public Sub(Sub pSource){}