子类中的唯一结构（C＃）

Question

I am developing an app that generates binary blobs from its input. As there are many types binary blob, I want to define a parent class called Config, and then multiple child classes. The parent class will have a method that generates the binary blob, with each child class having a unique struct that defines the format of the blob.

Parent:

class Config
{
    public struct BinaryFormat
    {
        public UInt16 _config_length;
    }

    // compile parameters to binary format
    public byte[] CompileToBinary()
    {
        // find the binary format struct
        ??????

        foreach (var field in typeof(BinaryFormat).GetFields(BindingFlags.Instance | BindingFlags.Public))
        {
            string identifier = field.Name;
            if (identifier == "_config_length")
                continue;
            ConfigParameter param = FindParameterByIdentifier(identifier);
            if (param == null)
                throw new Exception("Struct field with no matching parameter (" + identifier + ")");
            field.SetValue(null, param.value);
        }

        int size = Marshal.SizeOf(cfg);
        cfg._config_length = (UInt16)size;
        byte[] buffer = new byte[size];
        IntPtr ptr = Marshal.AllocHGlobal(size);
        Marshal.StructureToPtr(cfg, ptr, true);
        Marshal.Copy(ptr, buffer, 0, size);
        Marshal.FreeHGlobal(ptr);

        return buffer;
    }
}

Child:

class ChildConfig : Config
{
    [StructLayout(LayoutKind.Sequential)]
    public struct BinaryFormat
    {
        public UInt16 _config_length;

        public sbyte config1;
        public sbyte config2;
        public sbyte config3;
    }
}

In CompileToBinary() if I just create a new variable of type BinaryFormat it uses the struct from the parent class. How can I use the struct from the child class?

Or is this entirely the wrong way to go about this?

---

Solution, based on hints and code from m.rogalski.

Parent:

class Config
{
    public dynamic binary_struct;

    // compile parameters to binary format
    public byte[] CompileToBinary()
    {
        FieldInfo[] fieldinfo = Type.GetType(GetType().FullName + "+BinaryFormat").GetFields(BindingFlags.Instance | BindingFlags.Public);
        dynamic cfg = binary_struct;
        foreach (var field in fieldinfo)
        {
            string identifier = field.Name;
            if (identifier == "_config_length")
                continue;
            ConfigParameter param = FindParameterByIdentifier(identifier);
            if (param == null)
                throw new Exception("Struct field with no matching parameter (" + identifier + ")");
            field.SetValue(cfg, Convert.ChangeType(param.value, field.FieldType));
        }

        int size = Marshal.SizeOf(cfg);
        cfg._config_length = (UInt16)size;
        byte[] buffer = new byte[size];
        IntPtr ptr = Marshal.AllocHGlobal(size);
        Marshal.StructureToPtr(cfg, ptr, true);
        Marshal.Copy(ptr, buffer, 0, size);
        Marshal.FreeHGlobal(ptr);

        return buffer;
    }
}

Child:

class ChildConfig : Config
{
    public cfgSettings()
    {
        binary_struct = new BinaryFormat();
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct BinaryFormat
    {
        public UInt16 _config_length;

        public sbyte Config1;
        public sbyte Config2;
        public sbyte Config3;
    }
}

Answer 1

Use virtual/override or abstract/override method

Define a method which depends on the BinayFormat either as a parameter or use the protected variable. Then implement it in the child class. This way the functionality will be accessed only from the child class with the child's BinayFormat type.

But this has a downside, you wont be able to access the parent struct type. Will you ever use the parent struct type? If you want to use them interchangeably you might want both of them depend on an common interface.

Answer 2

So first of all your ChildConfig class will throw very annoying warning about hiding member something...

class ChildConfig : Config
{
    [StructLayout(LayoutKind.Sequential)]
    public new struct BinaryFormat // now it wont
    {
        public UInt16 _config_length;

        public sbyte config1;
        public sbyte config2;
        public sbyte config3;
    }
}

Second thing is that in C# you can get type by specifying it's "path":

namespace.class.insideclass+inside_structure

But the best thing is that most of the methods are invoked in to "top-most" object so for example if you call GetType() from Config it will return Config 's class Type but if called from ChildConfig it will return ChildConfig 's class Type ( brilliant as ... ).

Knowing thease things you should consider rebuilding your logic a bit:

// this was originaly
//foreach (var field in typeof(BinaryFormat).GetFields(BindingFlags.Instance | BindingFlags.Public))

// this should work with every BinaryFormat you want
foreach (var field in Type.GetType(GetType().FullName + "+BinaryFormat").GetFields(BindingFlags.Instance | BindingFlags.Public))

To create an instance you can add method inside the base Config object :

public object CreateInstance()
{
    return Activator.CreateInstance(Type.GetType(GetType().FullName + "+BinaryFormat"));
}

And then use it inside your derived classes:

class ChildConfig : Config
{
    private BinaryFormat _format = (BinaryFormat)CreateInstance();
}

Check it out here