c# - 保存相关常量的最佳实践？

Question

在我的游戏中，我有一个具有不同 GameEntityType 的枚举(大约 200 个条目)。

保存游戏时，只有 GameEntityType 数组写入保存文件。

重建游戏世界，并显示有关GameEntityTypes的各种信息我需要列出更多额外的细节(常量值)。这意味着每个 GameEntityType 都有与之关联的其他值。每帧都经常访问这些值。我的目标是通过一种简单的方法从 GameEntityTypeID(枚举)中获取所有额外信息。例如，当我从保存文件中读取 0x1 时，我可以简单地访问名称和所有其他数组中的数字/枚举隐含的信息，如下所示:“Constants.TextureList[GameEntityType]”，将返回字符串 "Stone_Texture.DDS"

第一个枚举条目的附加/关联信息示例:

类型:字符串, 字符串, Flag-Enum: "Visual-Classification", bool, bool值(value)观:“StoneBlock”，“Stone_Texture.DDS”，0x0102，false，true

我的第一个方法是创建一个静态的 GameEntityTypeInfo 类对于每个附加信息类型，都有如下成员:

public static const string[] = {"StoneBlock", ...[更多条目]};

当然这是一个糟糕的解决方案，因为我不能只添加 GameEntityType 的无论我想去哪里，都不必更新所有其他列表。我还必须将逻辑单元分成数据类型单元(这是个问题!因为当我决定不再需要特定的 EntityType 时，我必须遍历 6 个以上的列表!)

接下来，我尝试通过使用这些数据集构建结构来解决这个问题并将它们添加到静态数组中。但是在构造函数时(游戏开始时)创建一个包含附加信息的列表似乎仍然不是最佳解决方案。

问题:我如何创建快速(名称/分类查找将在每一帧中使用至少 5000 次)并轻松访问(最好使用索引器)这些常量值？

与此类似的查找最好是“Constants.TextureList[GameEntityType]”

Answer 1

通过子类化:

public abstract class Enumeration : IComparable
{
private readonly int _value;
private readonly string _displayName;

protected Enumeration()
{
}

protected Enumeration(int value, string displayName)
{
    _value = value;
    _displayName = displayName;
}

public int Value
{
    get { return _value; }
}

public string DisplayName
{
    get { return _displayName; }
}

public override string ToString()
{
    return DisplayName;
}

public static IEnumerable<T> GetAll<T>() where T : Enumeration, new()
{
    var type = typeof(T);
    var fields = type.GetFields(BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);

    foreach (var info in fields)
    {
        var instance = new T();
        var locatedValue = info.GetValue(instance) as T;

        if (locatedValue != null)
        {
            yield return locatedValue;
        }
    }
}

public override bool Equals(object obj)
{
    var otherValue = obj as Enumeration;

    if (otherValue == null)
    {
        return false;
    }

    var typeMatches = GetType().Equals(obj.GetType());
    var valueMatches = _value.Equals(otherValue.Value);

    return typeMatches && valueMatches;
}

public override int GetHashCode()
{
    return _value.GetHashCode();
}

public static int AbsoluteDifference(Enumeration firstValue, Enumeration secondValue)
{
    var absoluteDifference = Math.Abs(firstValue.Value - secondValue.Value);
    return absoluteDifference;
}

public static T FromValue<T>(int value) where T : Enumeration, new()
{
    var matchingItem = parse<T, int>(value, "value", item => item.Value == value);
    return matchingItem;
}

public static T FromDisplayName<T>(string displayName) where T : Enumeration, new()
{
    var matchingItem = parse<T, string>(displayName, "display name", item => item.DisplayName == displayName);
    return matchingItem;
}

private static T parse<T, K>(K value, string description, Func<T, bool> predicate) where T : Enumeration, new()
{
    var matchingItem = GetAll<T>().FirstOrDefault(predicate);

    if (matchingItem == null)
    {
        var message = string.Format("'{0}' is not a valid {1} in {2}", value, description, typeof(T));
        throw new ApplicationException(message);
    }

    return matchingItem;
}

public int CompareTo(object other)
{
    return Value.CompareTo(((Enumeration)other).Value);
}
}

这里有一篇文章:http://www.lostechies.com/blogs/jimmy_bogard/archive/2008/08/12/enumeration-classes.aspx