1

我有一个数组，其中包含以下格式的数据结构的字段；

[0] = Record 1 (Name Field)
[1] = Record 1 (ID Field)
[2] = Record 1 (Other Field)
[3] = Record 2 (Name Field)
[4] = Record 2 (ID Field)
[5] = Record 2 (Other Field)

等等

我正在将其处理成一个集合，如下所示；

for (int i = 0; i < components.Length; i = i + 3)
{
    results.Add(new MyObj
        {
            Name = components[i],
            Id = components[i + 1],
            Other = components[i + 2],
        });
}

这很好用，但我想知道是否有一种很好的方法可以使用 LINQ 实现相同的输出？这里没有功能要求，我只是好奇它是否可以完成。

我确实做了一些按索引分组的实验（在ToList()数组之后）；

var groupings = components
    .GroupBy(x => components.IndexOf(x) / 3)
    .Select(g => g.ToArray())
    .Select(a => new
        {
            Name = a[0],
            Id = a[1],
            Other = a[2]
        });

这行得通，但我认为这对于我正在尝试做的事情来说有点矫枉过正。for有没有更简单的方法来实现与循环相同的输出？

4

4 回答 4

2

我会说坚持你的for循环。但是，这应该适用于 Linq：

List<MyObj> results = components
    .Select((c ,i) => new{ Component = c, Index = i })
    .GroupBy(x => x.Index / 3)
    .Select(g => new MyObj{
        Name = g.First().Component,
        Id = g.ElementAt(1).Component,
        Other = g.Last().Component
    })
    .ToList();
于 2013-02-18T10:55:22.000 回答
2

看起来像是 Josh Einstein 的IEnumerable.Batch扩展的完美候选者。它将一个可枚举对象分割成一定大小的块，并将它们作为数组的枚举提供：

public static IEnumerable<T[]> Batch<T>(this IEnumerable<T> self, int batchSize)

在这个问题的情况下，你会做这样的事情：

var results = 
    from batch in components.Batch(3)
    select new MyObj { Name = batch[0], Id = batch[1], Other = batch[2] };

更新：2 年过去了，我链接到的 Batch 扩展似乎已经消失了。由于它被认为是问题的答案，以防万一其他人发现它有用，这是我当前的实现Batch：

public static partial class EnumExts
{
    /// <summary>Split sequence into blocks of specified size.</summary>
    /// <typeparam name="T">Type of items in sequence</typeparam>
    /// <param name="sequence"><see cref="IEnumerable{T}"/> sequence to split</param>
    /// <param name="batchLength">Number of items per returned array</param>
    /// <returns>Arrays of <paramref name="batchLength"/> items, with last array smaller if sequence count is not a multiple of <paramref name="batchLength"/></returns>
    public static IEnumerable<T[]> Batch<T>(this IEnumerable<T> sequence, int batchLength)
    {
        if (sequence == null)
            throw new ArgumentNullException("sequence");
        if (batchLength < 2)
            throw new ArgumentException("Batch length must be at least 2", "batchLength");

        using (var iter = sequence.GetEnumerator())
        {
            var bfr = new T[batchLength];
            while (true)
            {
                for (int i = 0; i < batchLength; i++)
                {
                    if (!iter.MoveNext())
                    {
                        if (i == 0)
                            yield break;
                        Array.Resize(ref bfr, i);
                        break;
                    }

                    bfr[i] = iter.Current;
                }
                yield return bfr;
                bfr = new T[batchLength];
            }
        }
    }
}

此操作是延迟的、单次枚举的并在线性时间内执行。与我见过的其他一些实现相比，它相对较快Batch，即使它为每个结果分配一个新数组。

这只是表明：在您进行分析之前，您永远无法分辨，并且您应该始终引用代码以防它消失。

于 2013-02-18T11:16:51.727 回答
1

也许迭代器可能是合适的。

声明一个自定义迭代器：

static IEnumerable<Tuple<int, int, int>> ToPartitions(int count)
{
    for (var i = 0; i < count; i += 3)
        yield return new Tuple<int, int, int>(i, i + 1, i + 2);
}

准备以下 LINQ：

var results = from partition in ToPartitions(components.Length)
              select new {Name = components[partition.Item1], Id = components[partition.Item2], Other = components[partition.Item3]};
于 2013-02-18T11:04:20.180 回答
1

这种方法可以让您了解如何使代码更具表现力。

public static IEnumerable<MyObj> AsComponents<T>(this IEnumerable<T> serialized)
    where  T:class
{
    using (var it = serialized.GetEnumerator())
    {
        Func<T> next = () => it.MoveNext() ? it.Current : null;

        var obj = new MyObj
            {
                Name  = next(),
                Id    = next(),
                Other = next()
            };

        if (obj.Name == null)
            yield break;

        yield return obj;
    }
}

就目前而言，我不喜欢检测输入结束的方式，但您可能拥有有关如何更好地执行此操作的特定于域的信息。

于 2013-02-18T11:13:45.583 回答