Question

在派生组合时，生成自动生成数字的可能方法是什么。

public enum Color
{
    Red,Green,Blue
}

public enum Vehicle
{
    Car,Bike
}

（即）{Red，Car}，{Red，Bike}，{Green，Car}，{Green，Bike} ......

（Jon Skeet帮助我解决了这个问题。）

var query = from Color c in Enum.GetValues(typeof(Color))
            from Vehicle v in Enum.GetValues(typeof(Vehicle))
            select new { Color = c, Vehicle = v };

现在我想要像这样的组合

{1,Red,Car},{2,Red,Bike},{3,Green,Car},{4,Green,Bike},{5,Blue,Car},{6,Blue,Bike}

生成自动数字的方法是什么？

Answer 1

另一种选择是使用包含项目索引的重载Select method。基于原始查询，您可以使用：

var indexedQuery = query.Select((item, i) => new { Index = i + 1, Item = item });
foreach (var o in indexedQuery)
{
   Console.WriteLine("{0},{1},{2}", o.Index, o.Item.Color, o.Item.Vehicle);
}

Answer 2

尝试：

int optionNumber = 0;
var query = from Color c in Enum.GetValues(typeof(Color))
            from Vehicle v in Enum.GetValues(typeof(Vehicle))
            select new { Number = optionNumber++, Color = c, Vehicle = v };

Answer 3

解决方案＃1：我相信这是最有效的LINQ-Like解决方案。它使用置换计数来有效地枚举;实际上，它可以用于任何不改变默认值（0,1,2，... n）

的枚举

int colorCount = Enum.GetValues(typeof(Color)).Length;
int vehicleCount = Enum.GetValues(typeof(Vehicle)).Length;
var permutations = Enumerable
                   .Range(0, colorCount * vehicleCount)
                    .Select (index => 
                               new {
                                     Index = index + 1,
                                     Color = (Color)(index / colorCount),
                                     Vehicle = (Vehicle)(index % vehicleCount)
                                   });

解决方案＃2：这个实际上是最有效的解决方案，因为它实际上不会枚举任何东西，给你一个O（1）解决方案，但它有一个丑陋的黑客那里做（T）（对象）（int）。使用风险。

class Permutations<T1, T2> : IEnumerable<Tuple<int, T1, T2>>
    where T1 : struct
    where T2 : struct
{
    int countT1 = 0;
    int countT2 = 0;

    public Permutations()
    {
        countT1 = Enum.GetValues(typeof(T1)).Length;
        countT2 = Enum.GetValues(typeof(T2)).Length;        
    }

    public int Length
    {
        get {
            return countT1 * countT2;
        }
    }

    public Tuple<int, T1, T2> this[int index]
    {
        get {
            Contract.Requires(index >= 1, "Index is out of lower bounds: Options are 1 - N.");
            Contract.Requires(index <= Length, "Index is out of upper bound.");                 
            return new Tuple<int, T1, T2>(
                       index,
            /*Hack ->*/(T1)(object)((index - 1) / countT1),
            /*Hack ->*/(T2)(object)((index - 1) % countT2));
        }
    }

    public IEnumerator<Tuple<int, T1, T2>> GetEnumerator()
    {
        return Enumerable.Range(1, this.Length).Select (i => this[i]).GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

void Main()
{       
    var permutations = new Permutations<Color, Vehicle>();
    // Can be accesed individually:
    var permutation = permutations[1];
    // Can be accesed using Enumerations
    permutations.Dump(); // LINQPad Dump
}

C＃LINQ自动生成的数字或索引

3 个答案: