在自定义类型上使用集合初始化器语法？

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
}

这可能吗？我想这是因为a的KeyValuePair's' Dictionary<>可以用这种方式初始化.

MSDN国家:

初始化集合初始化程序时,可以在初始化实现IEnumerable的集合类时指定一个或多个元素初始化程序.元素初始值设定项可以是简单值,表达式或对象初始值设定项.通过使用集合初始值设定项,您不必在源代码中指定对类的Add方法的多个调用; 编译器添加调用.

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

Answer 1

我认为你需要制作一个自定义集合而不是List.例如,将其称为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

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

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:Add为每个子括号集调用方法.

这是所有有给它.考虑以下hack:

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);
    }
}

你不应该在一个真正的程序中这样做,但我希望检查这个例子和结果,特别是如果你通过它调试步骤,将帮助你清楚地理解初始化器并为你当前的场景选择一个好的解决方案.