C# 使用System.Reflection检索常量字符串字段列表

我已经创建了一个类的类（显示其中一个）与常量字符串，我想Itaate上

public static class HTDB_Cols
{
    public sealed class Assistant
    {
        public const string EntryID  = "entryID",
                CustName  = "custName",
                SerialNum  = "serialNum",
                UserName  = "userName",
                Password  = "password",
                EndDate  = "end_date",
                CustID  = "custID",
                TmpCheck  = "tmpCheck",
                Isfamily  = "isfamily",
                Isserver  = "isserver";
    }
}               

public static class DB
{    
    public static void insert(string TableName)
    {
        ColumnsCollection = typeof(HTDB_Cols).GetNestedTypes().Where(f => f.DeclaringType.Name.ToLower().Equals(TableName.ToLower()));
    } 
}

上面的代码显示了我的尝试，但即使经过大量的尝试和错误，我仍然无法正确执行

我想要一个所有列的列表作为常量集合数组或列表

var dict = typeof(HTDB_Cols).GetNestedTypes()
            .First(t=>String.Compare(t.Name,TableName,true)==0)
            .GetFields()
            .ToDictionary(f => f.Name, f => f.GetValue(null));

获取列表

var list = typeof(HTDB_Cols).GetNestedTypes()
            .First(t => String.Compare(t.Name, TableName, true) == 0)
            .GetFields()
            .Select(f => f.GetValue(null) as string)
            .ToList();

---

看起来您需要的是一个

枚举

：

enum Assistant
{
    EntryID,
    CustName,
    SerialNum,
    UserName,
    Password,
    EndDate,
    CustID,
    TmpCheck,
    Isfamily,
    Isserver
};

然后，通过执行以下操作，可以将所有这些名称作为字符串获取：

string[] allNames = Enum.GetNames(typeof(Assistant));

只要变量的名称是您关心的实际值是可以接受的，那么这是一个有效的选项。我注意到它们在您的示例中并不完全相同，但主要是外壳。如果可以使用变量名作为值，或者将变量名更改为所需的值，那么这可能是最好的选择

现在，如果变量名与它们所表示的值不同真的很重要，或者如果您需要表示非法标识符的值（例如，您的一个值有一个空格，这是不好的，它们不能以数字开头，或者它们可能太长而不能作为一个方便的名称）。如果是这样，那么您真正想要的是一个由字符串支持的枚举，而不是整数或其他数字类型。这在C#中严格来说是不可能的，但由于这是在我实际编写以下类之前出现的，这是我创建自己的字符串备份枚举的最佳尝试。如果您确实需要不同于它们所表示的字符串值的变量名，这应该适合您

所有重要的东西都在最上面，在

等于之后的大多数东西都只是语法上的糖分

public struct StringEnum
{
    #region Code that is to be configured
    //For each value to be publicly exposed add a new field.
    public static readonly StringEnum Alpha = new StringEnum("Alpha Value");
    public static readonly StringEnum Beta = new StringEnum("Beta Value");
    public static readonly StringEnum Invalid = new StringEnum("Invalid");


    public static IEnumerable<StringEnum> AllValues
    {
        get
        {
            yield return Alpha;
            yield return Beta;
            yield return Invalid;
            //...
            //add a yield return for all instances here.

            //TODO refactor to use reflection so it doesn't need to be manually updated.
        }
    }

    #endregion
    private string value;

    /// <summary>
    /// default constructor
    /// </summary>
    //private Group()
    //{
    //    //You can make this default value whatever you want.  null is another option I considered 
    //    //(if this is a class an not a struct), but you 
    //    //shouldn't have this be anything that doesn't exist as one of the options defined at the top of 
    //    //the page.
    //    value = "Invalid";
    //}
    /// <summary>
    /// primary constructor
    /// </summary>
    /// <param name="value">The string value that this is a wrapper for</param>
    private StringEnum(string value)
    {
        this.value = value;
    }

    /// <summary>
    /// Compares the StringEnum to another StringEnum, or to a string value.
    /// </summary>
    /// <param name="obj"></param>
    /// <returns></returns>
    public override bool Equals(object obj)
    {
        if (obj is StringEnum)
        {
            return this.Equals((StringEnum)obj);
        }

        string otherString = obj as string;
        if (otherString != null)
        {
            return this.Equals(otherString);
        }

        throw new ArgumentException("obj is neither a StringEnum nor a String");
    }

    /// <summary>
    /// Strongly typed equals method.
    /// </summary>
    /// <param name="other">Another StringEnum to compare this object to.</param>
    /// <returns>True if the objects are equal.</returns>
    public bool Equals(StringEnum other)
    {
        return value == other.value;
    }

    /// <summary>
    /// Equals method typed to a string.
    /// </summary>
    /// <param name="other">A string to compare this object to.  
    /// There must be a Group associated with that string.</param>
    /// <returns>True if 'other' represents the same Group as 'this'.</returns>
    public bool Equals(string other)
    {
        return value == other;
    }

    /// <summary>
    /// Overridden equals operator, for convenience.
    /// </summary>
    /// <param name="first"></param>
    /// <param name="second"></param>
    /// <returns>True if the objects are equal.</returns>
    public static bool operator ==(StringEnum first, StringEnum second)
    {
        return object.Equals(first, second);
    }

    public static bool operator !=(StringEnum first, StringEnum second)
    {
        return !object.Equals(first, second);
    }

    /// <summary>
    /// Properly overrides GetHashCode so that it returns the hash of the wrapped string.
    /// </summary>
    /// <returns></returns>
    public override int GetHashCode()
    {
        return value.GetHashCode();
    }

    /// <summary>
    /// returns the internal string that this is a wrapper for.
    /// </summary>
    /// <param name="stringEnum"></param>
    /// <returns></returns>
    public static implicit operator string(StringEnum stringEnum)
    {
        return stringEnum.value;
    }

    /// <summary>
    /// Parses a string and returns an instance that corresponds to it.
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    public static StringEnum Parse(string input)
    {
        return AllValues.Where(item => item.value == input).FirstOrDefault();
    }

    /// <summary>
    /// Syntatic sugar for the Parse method.
    /// </summary>
    /// <param name="other"></param>
    /// <returns></returns>
    public static explicit operator StringEnum(string other)
    {
        return Parse(other);
    }

    /// <summary>
    /// A string representation of this object.
    /// </summary>
    /// <returns></returns>
    public override string ToString()
    {
        return value;
    }
}

公共结构StringEnum
{
#要配置的区域代码
//对于要公开的每个值，添加一个新字段。
公共静态只读StringEnum Alpha=新StringEnum（“Alpha值”）；
公共静态只读StringEnum Beta=新StringEnum（“Beta值”）；
公共静态只读StringEnum无效=新StringEnum（“无效”）；
公共静态IEnumerable AllValue
{
得到
{
收益率α；
收益率β；
收益率返回无效；
//...
//在此处为所有实例添加收益率回报。
//TODO重构以使用反射，因此不需要手动更新。
}
}
#端区
私有字符串值；
/// 
///默认构造函数
/// 
//私人组（）
//{
////您可以随意设置此默认值。null是我考虑的另一个选项
////（如果这是一个类而不是结构），但您
////不应该有任何不存在的选项，这些选项定义在
////这一页。
//value=“无效”；
//}
/// 
///主构造函数
/// 
///这是其包装的字符串值
私有StringEnum（字符串值）
{
这个值=值；
}
/// 
///将StringEnum与另一个StringEnum或字符串值进行比较。
/// 
/// 
/// 
公共覆盖布尔等于（对象对象对象）
{
if（对象为StringEnum）
{
返回此.Equals（（StringEnum）obj）；
}
字符串otherString=obj作为字符串；
如果（其他字符串！=null）
{
返回此.Equals（其他字符串）；
}
抛出新ArgumentException（“obj既不是StringEnum也不是字符串”）；
}
/// 
///强类型等于方法。
/// 
///要将此对象与之进行比较的另一个StringEnum。
///如果对象相等，则为True。
公共布尔等于（StringEnum其他）
{
返回值==other.value；
}
/// 
///等于键入字符串的方法。
/// 
///要将此对象与之进行比较的字符串。
///必须有一个组与该字符串关联。
///如果“其他”表示与“此”相同的组，则为True。
公共布尔等于（字符串其他）
{
返回值==其他；
}
/// 
///为方便起见，重写等于运算符。
/// 
/// 
/// 
///如果对象相等，则为True。
公共静态布尔运算符==（StringEnum第一，StringEnum第二）
{
返回object.Equals（第一，第二）；
}
公共静态布尔运算符！=（StringEnum第一，StringEnum第二）
{
return！object.Equals（第一，第二）；
}
/// 
///正确重写GetHashCode，以便它返回包装字符串的哈希值。
/// 
/// 
公共覆盖int GetHashCode（）
{
返回值。GetHashCode（）；
}
/// 
///返回作为包装器的内部字符串。
/// 
/// 
/// 
公共静态隐式运算符字符串（StringEnum StringEnum）
{
返回stringEnum.value；
}
/// 
///解析字符串并返回与其对应的实例。
/// 
/// 
/// 
公共静态StringEnum解析（字符串输入）
{
返回AllValues.Where（item=>item.value==input）.FirstOrDefault（）；
}
/// 
///解析方法的同步糖。
/// 
/// 
/// 
公共静态显式运算符StringEnum（字符串其他）
{
返回解析（其他）；
}
/// 
///此对象的字符串表示形式。
/// 
/// 
公共重写字符串ToString（）
{
返回值；
}
}
谢谢，不过如果我必须只选择其中一个，我会选择它，因为它是密封类中的const strings，所以我也可以以“单一”模式访问它：
var Name=Assistant.UserName
@LoneXcoder您可以这样做，它只是：
string name=Assistant.UserName.ToString（）。另外，如果你真的想要更健壮的解决方案，请参见编辑。对不起，虽然我讨厌字符串，但如果我能让你理解我的观点，它只是