Question

I want to be able to loop through a Class Property that references its own properties. Why you may ask? Because it’s easier to manage later on if I want to add more properties to that Class.

Let me explain more:

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)
    {
        // Assign SolidSpecificProperty from string
    }
}

public class Liquid : Element
{
    public Liquid(string stringData) : base(stringData) { }
    public string LiquidSpecificProperty { get; set; }
    protected override void DefFromFile(string stringData)
    {
        // Assign LiquidSpecificProperty from string
    }
}

public class Gas : Element
{
    public Gas(string stringData) : base(stringData) { }
    public string GasSpecificProperty { get; set; }
    protected override void DefFromFile(string stringData)
    {
        // Assign GasSpecificProperty from string
    }
}

public abstract class ElementBox<T> : IElementBox where T : Element
{
    public List<T> Elements { get; set; }
    public List<T> 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<Solid>
{
    public override string Filename
    {
        get { return "Solid.txt"; }
    }
    public override void ExtractFromFile(string stringData)
    {
        this.Elements.Add(new Solid(stringData));
    }
}

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

public class GasBox : ElementBox<Gas>
{
    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());
        }
    }
}

The whole purpose of this structure is to be able to define all the object properties in a text file. So that all the SolidBox.Elements objects are dynamically assigned from that text file definition.

My questions are as follow:

• Will the property array in DataDefinition be referenced by value. Which would mean that all my data assignation would get absorbed in the void?

• If yes (or no..), is their a better way of doing the whole thing / What would be the best way to do it?

I’ve been working on that data structure for a while now I’m getting proud of what I could achieve. I would be sad if all that was done for nothing. Although, if one if you can provide me with a better/optimal way of doing the whole thing, I will be grateful and throw my code in my archive folder.

Also, keep in mind that this is an example of the data structure. It does not reflect exactly what my code looks like and is made so to ease comprehension and reading.

Don’t hesitate to ask questions if more information is needed.

Answer 1

Deserialization (reading objects in from a persistent medium) has been solved a zillion different ways. Try using Data Contracts, like this answer demonstrates. You just need to add a few attributes to your properties to indicate what you want serialized and then it does just about all of the work for you.