在 object 构造中传递枚举并使用其属性 + 在 C# 中表示 memory 的最佳方式

Question

I need a way to represent some memory layout for all sorts of processors and thought it might be a good idea to provide this information through the use of enums.
Please suggest a better approach as I am not use using enums is the best option.

Now my enum for a given processor ProcX is the following one:

public static class ProcX
{
    public enum MemorySegments
    {
        [MemSize(0x500)]
        [Description("M0 base address")]
        M0 = 0x0000,

        [MemSize(0x500)]
        [Description("M1 base address")]
        M1 = 0x0500

        ...
    }
}

As mentioned above there will be many of these definitions and they should be used in order to instantiate and allocate memory segments.
So now, if you consider the following MemorySegment Class, see that I would like to allocate the memory within the constructor based on the enum passed to it at construction:

public class MemorySegment
{
    public uint BaseAddress;

    public uint MemSize;

    ....

    public MemorySegment(Enum segments, string segName)
    {
        BaseAddress = segments(segName).....??;
        MemSize= segments(segName) .....?;

        // Then allocate mem using these values
        ...
   }
}

Now if I try to create a segment of type M0:

MemorySegment mySeg = new MemorySegment(new ProcX.MemorySegments(), "M0");    // I am passing "M0" here for this example only

Within the "MemorySegment" constructor, how can I extract the desired enum fields. ie. For M0, we should be able to set BaseAddress to 0 and MemSize to 0x500 out of the informatino provided by the num.

For info, here are my enum attributes:

public class MemSizeAttribute : System.Attribute
{
    private int _value;
    public MemSizeAttribute(int value)
    {
        _value = value;
    }
    public int Value
    {
        get { return _value; }
    }
}

public static class EnumExtension
{
    public static int MemSize<T>(this T value)
    {
        FieldInfo fi = value.GetType().GetField(value.ToString());

        MemSizeAttribute[] attributes = (MemSizeAttribute[])fi.GetCustomAttributes(typeof(MemSizeAttribute), false);

        if (attributes.Length > 0)
            return attributes[0].Value;
        else
            return 0;
    }

    public static string Description<T>(this T value)
    {
        FieldInfo fi = value.GetType().GetField(value.ToString());

        DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);

        if (attributes.Length > 0)
            return attributes[0].Description;
        else
            return value.ToString();
    }
}

Finally, how could I cycle through each element of the enum one by one? ie. If I wanted to instantiate all the segments listed in this enum one by one (from within a loop).

Answer 1

"best" is always subjective; storing things as an enum is OK , but having to look everything up via attributes is pretty inefficient and allocatey. Frankly, if this was me I'd keep it simple:

public static class ProcX
{
    public static class MemorySegments {
        public static MemorySegment M0 {get;}
            = new MemorySegment (500, "M0 base address", 0x0000);
        public static MemorySegment M1 {get;}
            = new MemorySegment (500, "M1 base address", 0x0500);
        // ...
    }
}
public sealed class MemorySegment {
    public int Size {get; }
    public string Description {get;}
    public int BaseAddress {get;}
    internal MemorySegment(int size, string description, int baseAddress) {
        Size = size;
        Description = description;
        BaseAddress = baseAddress;
    }
}