C# 在IEnumerable和lt；对象[]>；和一个IEnumerable<；对象>；[]

有没有办法将

IEnumerable

转换为

IEnumerable[]

？具体地说，我有以下几点：

    IEnumerable<int[]> data = new List<int[]>()
    {
    new int[]{1,11},
    new int[]{2,22},
    new int[]{3,33},
    new int[]{4,44},
    // ...
    // ...
    };

IEnumerable数据=新列表（）
{
新int[]{1,11}，
新int[]{2,22}，
新int[]{3,33}，
新int[]{4,44}，
// ...
// ...
};

我想把它变成以下形状：

    IEnumerable<int>[] data = new List<int>[] 
    { 
    new List<int>(){1,2,3,4 },
    new List<int>(){11,22,33,44}
    };

IEnumerable[]数据=新列表[]
{ 
新列表（）{1,2,3,4}，
新列表（）{11,22,33,44}
};

到目前为止，我提出的唯一解决方案如下：

public static IEnumerable<int>[] Convert(IEnumerable<int[]> data)
{
    var length = data.First().Length;
    var output = new List<int>[length];
    for (int i = 0; i < length; i++)   
        output[i] = new List<int>();
    foreach (var entry in data) 
    {
        for (int i = 0; i < length; i++)    
        {
            output[i].Add(entry[i]);
        }
    }
    return output;
}

公共静态IEnumerable[]转换（IEnumerable数据）
{
var length=data.First（）.length；
var输出=新列表[长度]；
for（int i=0；i

---

但这并不理想，因为我需要迭代整个数据集。理想的解决方案将是使用LINQ或内置迭代器模式特性（

yield return

）。有更好的解决方案吗？

如果您不介意对

数据进行多次枚举，可以执行以下操作：

public static IEnumerable<int>[] Convert(IEnumerable<int[]> data)
{
    var length = data.First().Length;
    var output = new IEnumerable<int>[length];
    for (int i = 0; i < length; i++)
    {
        output[i] = CustomEnumerable(i);
    }

    return output;

    IEnumerable<int> CustomEnumerable(int index)
    {
        foreach (var entry in data) 
        {
            yield return entry[index];
        }
    }
}

在这里，我添加了另一个
IEnumerable
，当我们迭代它时，它正在填充缓存
列表。因此，
数据
只迭代一次，后续迭代使用缓存

.
我和林克有一个简短的建议。通过下面的示例，您可以得到一个锯齿状数组

var maxLength = data.Max(x => x.Length);
var converted = new IEnumerable<int>[maxLength]
    .Select((dst, index) => data
        .Select(src => src.Length > index ? src[index] : default)
        .Where(n => n != default));

var maxLength=data.Max（x=>x.Length）；
var converted=新的IEnumerable[maxLength]
.选择（（dst，索引）=>数据
.Select（src=>src.Length>index？src[index]：默认值）
。其中（n=>n！=默认值））；

通过这个，你可以把你的源数组切割成矩阵

var minLength = data.Min(x => x.Length);
var converted = new IEnumerable<int>[minLength]
    .Select((dst, index) => data
        .Select(src => src[index]));

var minLength=data.Min（x=>x.Length）；
var converted=新的IEnumerable[minLength]
.选择（（dst，索引）=>数据
.Select（src=>src[index]）；
第二个建议的解决方案正是我所渴望的。非常感谢你。
var minLength = data.Min(x => x.Length);
var converted = new IEnumerable<int>[minLength]
    .Select((dst, index) => data
        .Select(src => src[index]));