Erstellen Sie eine Instanz der abgeleiteten Klasse durch die der Basisklasse ohne hardcoding

Mein problem ist wie folgt:

Ich habe eine base-Klasse muss Abstrakt sein. Es hat mehrere abgeleitete Klassen, jede mit Ihren eigenen besonderen Eigenschaften, die im Eigenschaften-Mitglied.

Ich muss in der Lage sein, erstellen Sie eine neue Instanz einer von dieser abgeleiteten Klassen, also alle Mitglieder sind gleichwertig, aber ändern Sie die neue Instanz nicht ändern, das original.

Endlich, ich will es tun, ohne zu fest in jeder abgeleiteten Typ der Basisklasse. (Das wäre, zugegeben, die einfachste Lösung sein, aber das ist nicht der Punkt)

Alle abgeleiteten Klassen gerecht "ist-ein" - Beziehung zur Basisklasse.

Hier ist der code:

public abstract class BaseClass
{
    //Default properties here
    int x, y, z, ...;

    //Custom made class to hold custom properties
    protected Attributes Properties;

    public BaseClass createNewInstance()
    {
        return createNewInstanceStep1();
    }

    //Each derived class implements their own version of this,
    //to handle copying any custom members contained in Properties.
    protected abstract BaseClass createNewInstanceStep2();

    protected BaseClass createNewInstanceStep1()
    {
        BaseClass newInstance = new BaseClass(); //<- Doesn't work because class is abstract

        //Copy default properties
        newInstance.x = x;
        newInstance.y = y;
        newInstance.z = z;

        //Call the new instance's step 2 method, and return the result.
        return newInstance.createNewInstanceStep2();
    }
}

Das Problem bei diesem code ist die BaseClass newKeyFrame = new BaseClass(); Linie. Als die Klasse ist Abstrakt, Sie kann nicht erstellen Sie eine Instanz von Ihr.

Das problem ist, dass ich in der Lage sein müssen den Konstruktor aufrufen, was den Typ der abgeleiteten Klasse ist, wie Sie alle anderen code in Ihre Konstruktoren, die nicht geteilt werden kann.

Ich habe gehört, dass mit der Spiegelung könnte eine praktikable Lösung, allerdings habe ich keine Ahnung wie.

Wie kann ich dies lösen, ohne fest in einem Fall, für jeden abgeleiteten Typ?

InformationsquelleAutor Ipquarx | 2013-10-30

abstract-class c#constructor inheritance

Machen könnte createNewInstanceStep1 Generika. Ich habe auch geändert, die Step2 zu geben void (ich gehe davon aus, dass es zu ändern, die die aktuelle Instanz, also die Rendite wäre immer return this; sowieso), weil es sonst nicht wirklich Sinn macht die Art und Weise, die ich möchte um es hier zu verwenden. Wenn es nicht sinnvoll ist, es zu ändern, wie diese, dann mein ganzer Ansatz nur diese generische Methode will nicht funktionieren.

Sowie createNewInstance jetzt verwendet reflektion, um zu nennen, das äquivalent von return createNewInstanceStep1<this.GetType()>();.

public BaseClass createNewInstance()
{
    var method = typeof(BaseClass).GetMethod("createNewInstanceStep1", BindingFlags.NonPublic | BindingFlags.Instance).MakeGenericMethod(this.GetType());
    var value = method.Invoke(this, null);
    return (BaseClass)value;
}

//Each derived class implements their own version of this,
//to handle copying any custom members contained in Properties.
protected abstract void createNewInstanceStep2();

protected T createNewInstanceStep1<T>() where T : BaseClass, new()
{
    T newInstance = new T(); //works!

    //Copy default properties
    newInstance.x = x;
    newInstance.y = y;
    newInstance.z = z;

    //Call the new instance's step 2 method, and return the result.
    newInstance.createNewInstanceStep2();
    return newInstance;
}

Wenn dies nicht funktioniert, wird ein weiterer Ansatz ist eine selbst-referenzielle generischen Typ. Es ist gut, um dies zu vermeiden, da es verwirrend ist und insgesamt ein gutes design.

public sealed class SubClass : BaseClass<SubClass>
{
    protected override SubClass createNewInstanceStep2()
    {
        Console.WriteLine("In step 2");
        return this;
    }
}
public abstract class BaseClass<T> where T : BaseClass<T>, new()
    public T createNewInstance()
    {
        return createNewInstanceStep1();
    }

    //Each derived class implements their own version of this,
    //to handle copying any custom members contained in Properties.
    protected abstract T createNewInstanceStep2();

    protected T createNewInstanceStep1()
    {
        T newInstance = new T();
        ...

Hat wunderbar funktioniert. Dürfte ich Fragen, was die where T : BaseClass, new() ist zu tun?
Es ist zwei Einschränkungen: T muss ein BaseClass (entweder BaseClass oder etwas, dass das reicht), und es muss verfügbar, einen parameterlosen Konstruktor. Dies stellt sicher, dass Sie tun können new T() und verwenden newInstance wie ein BaseClass.

InformationsquelleAutor Tim S.

Was ist das problem mit der Vermietung der abgeleiteten Klassen müssen die Instanziierung der neuen Instanz?

public abstract class BaseClass
{
    //Default properties here
    int x, y, z, ...;

    //Custom made class to hold custom properties
    protected Attributes Properties;

    public abstract BaseClass createNewInstance();

    protected void CopyData(BaseClass original)
    {
        this.x = original.x;
        this.y = original.y;
        this.z = original.z;
    }
}

public class ChildClass : BaseClass
{
    public BaseClass createNewInstance()
    {
        ChildClass newInstance = new ChildClass();
        newInstance.CopyData(this);

        //Do any additional copying
        return newInstance;
    }
}

Wenn ich dies Tue, dann muss ich das umschreiben, kopieren Sie alle gemeinsame Eigenschaften. Es ist nicht viel, aber es ist immer noch nicht so effizient, wie ich möchte, es zu werden.
Nein, tun Sie nicht. Wie Sie sehen können, das kopieren der freigegebenen Eigenschaften verarbeitet wird, in BaseClass.CopyData. Sie müssen nur sicher sein, rufen Sie CopyData von jedem ChildClass.createNewInstance
Falsch verstanden, der code, Hoppla. Ja, das würde gut funktionieren. Es IST einfacher und passt den gleichen Zweck. (albiet mit ein paar änderungen am code) +1

InformationsquelleAutor Jon

0

Können Sie machen createNewInstanceStep1 eine protected void init-Methode, leitet dieses Objekt, und rufen Sie in jede Unterklasse den Konstruktor.

InformationsquelleAutor Max Yankov
0

Wie wollen Sie wissen, welche Art von Instanz zu erstellen? Wenn Sie eine vorhandene Instanz der abgeleiteten Klasse und wollen, erstellen einer anderen Instanz, das ist im Grunde identisch ist, sollten Sie Ihre Basis-Typ implementieren Sie eine geschützte virtuelle CloneBase Methode, die Anrufe MemberwiseClone und hat keine tiefen kopieren der base-Typ kennt, und einen öffentlichen Clone Methode, die Ketten zu CloneBase und casts an der Basis geben. Jedes abgeleitete Typen überschreiben sollten CloneBase um die Kette zu base.CloneBase und fügen eventuell notwendige zusätzliche Tiefe zu kopieren (dieser Schritt kann ausgelassen werden, wenn keine zusätzlichen deep-copy Logik erforderlich ist), und auch die Schatten der öffentlichen Clone - Methode mit einem, die Ketten zu CloneBase auf und CASTET das Ergebnis seiner Art [über einen separaten CloneBase macht es möglich, beide deklarieren Sie eine neue Clone Methode mit einer anderen Signatur, während auch überschreiben und die Verkettung mit der Basis-Methode der Klasse].

Wenn Sie eine vorhandene Instanz von der neuen Klasse, aber wollen, dessen Eigenschaften kopiert werden von einigen anderen Beispiel, könnte eine abstrakte ConstructInstanceLike(x) Methode, die jeden abgeleiteten Typ implementieren würden entweder rufen einer Ihrer Konstruktoren, oder Klonen Sie sich selbst und ändern Sie den Klon entsprechen dem übergebenen Objekt. Weder Ansatz ist besonders elegant, aber entweder funktionieren kann.

Wenn Sie nicht über eine vorhandene Instanz von der neuen Klasse müssen Sie einige andere Mittel, um etwas von dem entsprechenden Typ. Der schönste Ansatz ist wahrscheinlich zum speichern einer Sammlung von Func<TParams, TResult> Delegierten, einer für jeden abgeleiteten Typ von Interesse, und rufen Sie dann eine dieser Funktionen zu erzeugen Sie ein Objekt von einer der zugehörigen abgeleiteten Typ. Es wäre auch möglich zu definieren, eine Schnittstelle
```
IFactory<TParam, TResult> { TResult Create(TParams param); }
```
aber in vielen Fällen eine Stellvertretung wird bequemer sein, mit zu arbeiten.
- Fragen Sie mich zu tun, was ich sagte, ich nicht haben wollen zu tun, das ist fest in jedem einzelnen abgeleiteten Typ.
- Ein Klon-basierter Ansatz würde nicht erfordern harte Codierung in den einzelnen abgeleiteten Klassen, die nicht das hinzufügen neuer Mitglieder, die Besondere Arbeit. Wenn Sie die Funktion-basierte Ansatz mit lambdas, wahrscheinlich könnte man eine Tabelle erstellen, die ziemlich gut mit einer Zeile source-code-pro unterstütztem Typ (so etwas wie AddFactory<FooBar>((x) => new FooBar(x));). Ist das zu viel "hard coding" für Ihren Geschmack?
- Es ist offensichtlich nicht allzu schwer zu tun, aber wieder die Frage-Staaten das Ziel, bis kein hardcoding notwendig auch immer, und die akzeptierte Antwort bietet genau das für mich. (Obwohl ich zugeben, das würde funktionieren einwandfrei)
- Die akzeptierte Antwort erfordert, dass die abgeleiteten Klassen müssen public parameterlosen Konstruktoren. Wenn man bereit waren, zu akzeptieren, dass die Bedingung, würde man nicht auf Reflexion zum erstellen der Instanzen; man könnte eine neue Instanz erstellen, und verwenden Sie dann eine CopyFrom - Methode auf die Instanz (was könnte es Erben von der Basisklasse) zu kopieren Ihrer Mitglieder. Ein Ansatz, der MemberwiseClone könnten, zu vermeiden die Notwendigkeit für eine new Einschränkung, obwohl, müsste man vorsichtig sein, um die Gültigkeit der Daten in dem geklonten Objekt die sollte nicht vorhanden sein, in die neue Instanz.
InformationsquelleAutor supercat

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.