Vorhandene, nicht änderbare Klasse mit eigenen Eigenschaften ergänzen

Ich möchte eine vorhandene Klasse mit eigenen Eigenschaften ergänzen.
Das (für mich) schwierige besteht darin, dass die Klasse, die ich ergänzen möchte innerhalb eines Konstruktes von Klassen enthalten ist.

Ich stelle dies nun nur anhand der folgenden Klassen dar: KlasseA, KLasseB, KlasseC
Es gibt also eine Vielzahl von Klassen, die nach folgenden Schema miteinander verbunden sind.

In KLasseA wird KlasseB instanziert.
In KlasseB wird die KlasseC instanziert.

Wenn ich also eine Eigenschaft aus Klasse C auslesen möchte erfolgt dies mit:

object X = KlasseA.KlasseB.KlasseC.myProperty;

Nun möchte ich der KlasseC eine neue Eigenschaft hinzufügen, um diese wie folgt auszulesen:

object Y = KlasseA.KlasseB.KlasseC.myNewProperty;

Einfach nur eine Ableitung von KlasseC zu erstellen und diese mit der gewünschten Eigenschaft zu ergänzen wird sicherlich nicht funktionieren, da KlasseB und KlasseA davon nix wissen.

Wie macht man das ???

Hallo Tester-05,

du fügst der KlasseC deine neue Eigenschat hinzu, das ist alles. Mit Ableitung bzw. Vererbung hat das nichts zu tun. Das sind allerdings absolute Grundlagen.

m0rius

Hallo mOrius,
ich kann doch der vorhandenen Klasse nur über Ableitung neue Eingenschfaten usw. zufügen oder ???

Klasse B instanziert Klasse C in seinem Konstruktor.
Woher soll der Konstuktor von KlasseB von meiner Ableitung wissen?

Vermutlich sehe ich den Wald vor lauter Bäumen nicht, aber mir ist nicht klar, we das so einfach funktionieren soll.

Viele Grüße
Tester-05

Woher kommt die Klasse? Einer selber erstellten kannst du hinzufügen was du willst, einer importierten nicht. Da würde ich mir dann die Eigenschaften woanders merken, kommt dann drauf an was du machen willst und was dabei rauskommen soll.

Hallo chilic,
ich importiere die Klasse und kann daher die Klasse nicht mal eben modifizieren.
Die Klasse selbst ist eigentlich schon ganz gut und verfügt über die Methoden ConvertToXml und ConvertFromXML.

Leider fehlen zwei wichtige Eigenschaften, die sich recht tief in der Klassenstruktur befinden.
Nun suchte ich nach einer Mögklichkeit diese Eigenschaft hinzuzufügen und wenn möglich die bereitgestellte Methoden ConvertToXml und ConvertFromXML zu nutzen.

Viele Grüße
Tester-05

Da helfen dir Extension Methods.

Darth Maim

Recht vielen Danke für den Tip. Hab ein wenig nachgelesen und probiert.

Ja ich kann tatsächlich eine zusätzliche Methode implementieren und aufrufen, aber wie erzeuge ich ein Feld oder aber Eigenschaft, in der ich Werte ablegen kann?

Wie helfen mir da Extension Methods.?
Wenn ich es recht verstehe gibt es keine Erweiterungseigenschaften oder doch ?

Viele Grüße
Tester-05

Am besten machst du das mit einer extra Datenklasse:

class FooData {
    private static Dictionary<Foo, FooData> _instances = new List<Foo>();

    public static FooData GetInstance(Foo foo) {
        if(!_instances.ContainsKey(foo)) {
            _instances.add(foo, new FooData(foo));
        }
        return _instances[foo];
    }

    private Foo _foo;
    private FooData(Foo foo) {
        _foo = foo;
    }

    //Alle zusätzlichen Methoden, Properties, ...
    private string _bla = "blubb";
    public string Bla {
        get { return _bla; }
        set { _bla = value; }
    }
}

Und dann die Extensionmethoden:

public static void SetBla(this Foo foo, string bla) {
    FooData.GetInstance(foo).Bla = bla;
}
public static string GetBla(this Foo foo) {
    return FooData.GetInstance(foo).Bla;
}

//Benutzung:
Foo foo = new Foo();
foo.SetBla("test");
string x = foo.GetBla(); // x = "test"

oder so:

public static FooData Data(this Foo foo) {
    return FooData.GetInstance(foo);
}

//Benutzung:
Foo foo = new Foo();
foo.Data().Bla = "test";
string x = foo.Data().Bla; // x = "test"

Darth Maim

Edit: Aber dann auch noch Methoden bereitstellen, mit denen FooData Instanzen wieder gelöscht werden, damit keine Daten für Foo-Objekte gespeichert werden, die längst nicht mehr existieren.

Nein es gibt keine Erweiterungseigenschaften. Du könntest dir aber z.B. sowas bauen:

public static class KlasseCExtensions
{
    private static Dictionary<KlasseC, Dictionary<String, Object>> _properties = new Dictionary<KlasseC, Dictionary<String, Object>>;

    public static Typ GetPropertyA(this KlasseC obj)
    {
         // Prüfung ob Dictionaryeinträge vorhanden sind
         // ...
         return _properties[obj]["PropertyA"];
    }

     public static Typ SetPropertyA(this KlasseC obj, Typ value)
     {
         // Prüfung ob Dictionaryeinträge vorhanden sind
         // ...
         _properties[obj]["PropertyA"] = value;
     }
}

Edit: Da war jemand schneller

Hallo,
recht vielen Dank für die ausführlichen Beispiele !!!

Die Lösung von Darth Maim gefällt mir eigentlich noch ein bischen besser.
Bin momentan unterwegs und werde das in den nächsten Tagen ausprobieren.

Nochmals Danke für die tollen Ideen !
Wäre ich sicherlich nie allein drauf gekommen.

Viele Grüße
Tester-05