Selbstreferenzielle Eigenschaften array

Question

Ich möchte in der Lage sein, durch eine Klasseneigenschaft zu iterieren, die auf ihre eigenen Eigenschaften verweist. Warum fragst du vielleicht? Weil es später einfacher zu verwalten ist, wenn ich mehr Eigenschaften zu dieser Klasse hinzufügen möchte.

Lass mich mehr erklären:

public interface IElementBox
{
    string Filename { get; }
    string FileDefinition { get; set; }
    void ExtractFromFile(string stringData);
}

public abstract class Element
{
    public Element(string stringData)
    {
        this.DefFromFile(stringData);
    }
    public string Name { get; set; }
    protected abstract void DefFromFile(string stringData);
}

public class Solid : Element
{
    public Solid(string stringData) : base(stringData) { }
    public string SolidSpecificProperty { get; set; }
    protected override void DefFromFile(string stringData)
    {
        // Füge SolidSpecificProperty aus dem String hinzu
    }
}

public class Liquid : Element
{
    public Liquid(string stringData) : base(stringData) { }
    public string LiquidSpecificProperty { get; set; }
    protected override void DefFromFile(string stringData)
    {
        // Füge LiquidSpecificProperty aus dem String hinzu
    }
}

public class Gas : Element
{
    public Gas(string stringData) : base(stringData) { }
    public string GasSpecificProperty { get; set; }
    protected override void DefFromFile(string stringData)
    {
        // Füge GasSpecificProperty aus dem String hinzu
    }
}

public abstract class ElementBox : IElementBox where T : Element
{
    public List Elements { get; set; }
    public List GetElementsFromName(string name)
    {
        return this.Elements.FindAll(x => x.Name == name);
    }
    public abstract string Filename { get; }
    public string FileDefinition { get; set; }
    public abstract void ExtractFromFile(string filename);
}

public class SolidBox : ElementBox
{
    public override string Filename
    {
        get { return "Solid.txt"; }
    }
    public override void ExtractFromFile(string stringData)
    {
        this.Elements.Add(new Solid(stringData));
    }
}

public class LiquidBox : ElementBox
{
    public override string Filename
    {
        get { return "Liquid.txt"; }
    }
    public override void ExtractFromFile(string stringData)
    {
        this.Elements.Add(new Liquid(stringData));
    }
}

public class GasBox : ElementBox
{
    public override string Filename
    {
        get { return "Gas.txt"; }
    }
    public override void ExtractFromFile(string stringData)
    {
        this.Elements.Add(new Gas(stringData));
    }
}

public static class DataDefinition
{
    public static SolidBox SolidBox { get; set; }
    public static LiquidBox LiquidBox { get; set; }
    public static GasBox GasBox { get; set; }

    public static IElementBox[] ElementBoxes = new IElementBox[] { DataDefinition.SolidBox, DataDefinition.LiquidBox, DataDefinition.GasBox };
}

public static class Loader
{
    public static void LoadInfo()
    {
        for (int elementBoxNb = 0; elementBoxNb < DataDefinition.ElementBoxes.Length; elementBoxNb++)
        {
            string dataFilepath = DataDefinition.ElementBoxes[elementBoxNb].Filename;
            System.IO.StreamReader sr = System.IO.File.OpenText(dataFilepath);
            DataDefinition.ElementBoxes[elementBoxNb].ExtractFromFile(sr.ReadToEnd());
        }
    }
}

Der gesamte Zweck dieser Struktur besteht darin, alle Objekteigenschaften in einer Textdatei zu definieren. So werden alle SolidBox.Elements-Objekte dynamisch aus dieser Textdateidefinition zugewiesen.

Meine Fragen lauten wie folgt:

• Wird das Eigenschaftsarray in DataDefinition per Wert referenziert. Was bedeuten würde, dass alle meine Datenzuweisungen im Nirgendwo verschwinden?

• Wenn ja (oder nein..), gibt es eine bessere Möglichkeit, das Ganze zu tun / Was wäre der beste Weg, es zu tun?

Ich arbeite schon eine Weile an dieser Datenstruktur und bin stolz auf das, was ich erreichen konnte. Ich wäre traurig, wenn all das umsonst wäre. Allerdings, wenn einer von Ihnen mir eine bessere/optimalere Möglichkeit zur Durchführung des Ganzen bieten kann, werde ich dankbar sein und meinen Code in meinen Archivordner werfen.

Außerdem beachten Sie, dass dies ein Beispiel für die Datenstruktur ist. Es spiegelt nicht genau wider, wie mein Code aussieht, sondern soll das Verständnis und die Lesbarkeit erleichtern.

Zögern Sie nicht, Fragen zu stellen, wenn weitere Informationen benötigt werden.

Answer 1

Die Deserialisierung (das Einlesen von Objekten aus einem persistenten Medium) wurde auf unzählige verschiedene Arten gelöst. Versuchen Sie, Datenverträge zu verwenden, wie diese Antwort zeigt. Sie müssen nur einige Attribute zu Ihren Eigenschaften hinzufügen, um anzuzeigen, was Sie serialisieren möchten, und dann erledigt es fast die gesamte Arbeit für Sie.

Answer 2

Dies wird nicht das tun, was Sie wollen. Das Array wird Referenzen auf die Objekte enthalten, auf die die Eigenschaften zum Zeitpunkt der Initialisierung verweisen, was in diesem Fall null sein wird. Wenn Sie etwas der Eigenschaft SolidBox zuweisen, ändert sich das zugehörige Element des Arrays nicht, und umgekehrt.