在自定义类型上使用集合初始值设定项语法？

Question

我有一个很大的静态列表，它基本上是一个查找表，所以我在代码中初始化该表。

private class MyClass
{
    private class LookupItem
    {
        public int Param1    { get; set; }
        public int Param2    { get; set; }
        public float Param2  { get; set; }
        public float Param4  { get; set; }
    }

    private static List<LookupItem> _lookupTable = new List<LookupItem>()
    { 
        new LookupItem() { Param1 = 1, Param2 = 2, Param3 = 3 Param4 = 4 },
        new LookupItem() { Param1 = 5, Param2 = 6, Param3 = 7 Param4 = 8 },
        //etc
    }
}

真正的 LookupItem 具有更多属性，因此我添加了一个构造函数以允许更紧凑的初始化格式：

private class MyClass
{
    private class LookupItem
    {
        public int Param1    { get; set; }
        public int Param2    { get; set; }
        public float Param2  { get; set; }
        public float Param4  { get; set; }

        public LookupItem(int param1, int param2, float param3, float param4)
        {
            Param1 = param1;
            Param2 = param2;
            Param3 = param3;
            Param4 = param4;    
        }
    }

    private static List<LookupItem> _lookupTable = new List<LookupItem>()
    { 
        new LookupItem(1, 2, 3, 4),
        new LookupItem(5, 6, 7, 8),
        //etc
    }
}

我真正想做的是对对象本身使用集合初始化程序格式，这样我就可以去掉每一行的new LookupItem()。例如：

private static List<LookupItem> _lookupTable = new List<LookupItem>()
{ 
    { 1, 2, 3, 4 },
    { 5, 6, 7, 8 },
    //etc
}

这可能吗？我喜欢认为这是因为 Dictionary 的 KeyValuePair 可以通过这种方式初始化。

MSDN 指出：

集合初始值设定项可让您指定一个或多个元素 当你初始化一个实现了的集合类时的初始化器 IEnumerable。元素初始值设定项可以是一个简单的值， 表达式或对象初始值设定项。通过使用集合初始值设定项 您不必指定多次调用 Add 方法 源代码中的类；编译器添加调用。

这是否意味着我需要在我的 LookupItem 类上实现 IEnumerable 并返回每个参数？不过，我的班级不是收藏班级。

Answer 1

我认为你需要创建一个自定义集合而不是列表。例如，将其称为 LookupItemTable。为该集合提供一个 Add(int, int, float, float) 方法并让它实现 IEnumerable。例如：

class LookupItem
{
    public int a;
    public int b;
    public float c;
    public float d;
}

class LookupItemTable : List<LookupItem>
{
    public void Add(int a, int b, float c, float d)
    {
        LookupItem item = new LookupItem();
        item.a = a;
        item.b = b;
        item.c = c;
        item.d = d;
        Add(item);
    }
}

private static LookupItemTable _lookupTable = new LookupItemTable {
    { 1, 2, 3, 4 },
    { 5, 6, 7, 8 }
};

我现在已经尝试了上面的代码，它似乎对我有用。

Answer 2

快速修复：使用带有多个参数的 Add 重载创建您自己的 List 类型：

class LookupList : List<LookupItem> {
    public void Add(int Param1, int Param2, ... sometype ParamX) {
        this.Add(new LookupItem() { Param1 = Param1, Param2 = Param2, ... ParamX = ParamX });
    }
}

现在完全按照您想要的方式工作：

    private static LookupList _lookupTable = new LookupList() {                  
        {1,2,3,4},                 
        {2,7,6,3}                
    };

更基本答案：

您混淆了对象初始值设定项 和 集合初始值设定项。简而言之：

对象初始值设定项是一种语法技巧，它在后台为具有指定值的每个命名属性调用属性设置方法。

集合初始值设定项是一种语法技巧，在后台：

• 对于 Array 类型：用项目填充数组
• 对于任何其他类型，必须实现 IEnumerable< /code>：为每个子括号集调用Add方法。

这就是它的全部内容。例如，考虑以下黑客：

public class Hack : IEnumerable {
    public int LuckyNumber { get; set; }
    public double Total { get; private set; }
    public void Add(string message, int operand1, double operand2, double operand3) {
        Console.WriteLine(message);
        this.Total += operand1 * operand2 - operand3;
    }
    public IEnumerator GetEnumerator() { throw new NotImplementedException(); }
}

class Program {
    static void Main(string[] args) {
        Hack h1 = new Hack() {
            { "Hello", 1, 3, 2},
            { "World", 2, 7, 2.9}
        };
        Console.WriteLine(h1.Total);
        Hack h2 = new Hack() { LuckyNumber = 42 };
        Console.WriteLine(h2.LuckyNumber);
    }
}

您永远不应该在真实的程序中执行此操作，但我希望检查此示例和结果，特别是如果您调试单步调试它，将帮助您清楚地理解初始化程序并为您当前的选择一个好的解决方案设想。

Answer 3

您尝试在列表本身而不是您的类型上使用集合初始值设定项：

// Note the "new List<...>" part - that specifies what type the collection
// initializer looks at...
private static List<LookupItem> _lookupTable = new List<LookupItem>()
{ 
    { 1, 2, 3, 4 },
    { 5, 6, 7, 8 },
}

因此它在 List 上寻找带有四个参数的 Add 方法，并且那不存在。

您必须实现自己的集合类才能使用自定义集合初始值设定项。当您使用 List 时，您会陷入构造函数调用的困境。

Answer 4

不要使用从 List派生的自定义类来掩盖 List 的意图，而是添加一个调用所需构造函数的简单扩展：

public static class LookupItemListExtensions
{
    public static void Add(this List<LookupItem> lookupItemList, int param1, int param2, float param3, float param4)
    {
        lookupItemList.Add(new LookupItem(param1, param2, param3, param4));
    }
}

请注意，您是为了简洁而牺牲清晰度，因此使用风险自负。使用“new ListItem”可以让您直接按 F12 进入构造函数；这个扩展不会（对于其他开发人员来说也不会是显而易见的）。

Answer 5

这是否意味着我需要在 LookupItem 类上实现 IEnumerable
并返回每个参数？不过，我的类不是集合类。

不，这意味着 List 实现了 IEnumerable，这就是为什么你可以写

private static List<LookupItem> _lookupTable = new List<LookupItem>()
{ 
    new LookupItem(1, 2, 3, 4),
    new LookupItem(5, 6, 7, 8),
    //etc
}

它也意味着如果你的 LookupItem 是一个集合，实现了 IEnumerable，你可以这样写：

private static List<LookupItem> _lookupTable = new List<LookupItem>()
{ 
    new LookupItem { new Item(), new Item() },
    new LookupItem { new Item(), new Item() }
}