C# Linq GroupBy和Join

我在用一台机器“解决”我客户的问题

我客户的问题就是这样的：

public class ClientProblem
{
    public int ClientID { get; set; }

    public string TaskToSolve { get; set; }
}

每天一次，我要准备一份今天要解决的所有问题的清单。列表如下所示：

List<ClientProblem> tasks = new List<ClientProblem>();

// Filling the list with task to be solved today

// list[0] = client 1 task 1
// list[1] = client 1 task 2
// ...
// list[n-1] = client 1 task n

// list[n+1] = client 2 task 1
// list[n+2] = client 2 task 2
// ...
// list[2n-1] = client 2 task 2n

// ...

// list[0] = client 1 task 1
// list[1] = client 2 task 1
// ...
// list[n] = client n task 1
// list[n+1] = client 1 task 2
// list[n+2] = client 2 task 2
// ...
// list[2n] = client n task 2
// ...

public static IEnumerable<T> Interleave<T>( IEnumerable<IEnumerable<T>> sequences )
{
    var enumerators = sequences.Select( s => s.GetEnumerator() ).ToArray();
    while ( true )
    {
        foreach ( var e in enumerators )
        {
            if ( e.MoveNext() )
            {
                yield return e.Current;
            }
            else
            {
                yield break;
            }
        }
    }
}

我想我应该使用linqgroupby和Join方法。

---

有可能用Linq解决这个问题吗？还有其他有效的解决方案吗？

您需要的是按客户机ID对任务进行分组，然后交错分组。恐怕LINQ没有交错方法，但您可以创建自己的，例如：

List<ClientProblem> tasks = new List<ClientProblem>();

// Filling the list with task to be solved today

// list[0] = client 1 task 1
// list[1] = client 1 task 2
// ...
// list[n-1] = client 1 task n

// list[n+1] = client 2 task 1
// list[n+2] = client 2 task 2
// ...
// list[2n-1] = client 2 task 2n

// ...

// list[0] = client 1 task 1
// list[1] = client 2 task 1
// ...
// list[n] = client n task 1
// list[n+1] = client 1 task 2
// list[n+2] = client 2 task 2
// ...
// list[2n] = client n task 2
// ...

public static IEnumerable<T> Interleave<T>( IEnumerable<IEnumerable<T>> sequences )
{
    var enumerators = sequences.Select( s => s.GetEnumerator() ).ToArray();
    while ( true )
    {
        foreach ( var e in enumerators )
        {
            if ( e.MoveNext() )
            {
                yield return e.Current;
            }
            else
            {
                yield break;
            }
        }
    }
}

公共静态IEnumerable交织（IEnumerable序列）
{
变量枚举数=序列。选择（s=>s.GetEnumerator（））.ToArray（）；
while（true）
{
foreach（枚举数中的变量e）
{
if（如MoveNext（））
{
收益率，收益率，电流；
}
其他的
{
屈服断裂；
}
}
}
}

---

该方法假设所有序列长度相同；如果不是这种情况，您将希望添加一个标志，指示枚举数是否返回了任何元素，并使循环条件依赖于此，而不是在一个序列结束时立即使用

产生中断。
定义以下扩展方法后

public static class SomeExtensions
{
    public static IEnumerable<T> InterleaveBy<T, S>(this IEnumerable<T> input, Func<T, S> selector)
    {
        return input
            .GroupBy(selector)
            .SelectMany(g => g.Select((x, i) => new { key = i, value = x }))
            .OrderBy(x => x.key)
            .Select(x => x.value);
    }
}

如果你有列表，那么

var newList = tasks.SelectMany(x => x).InterleaveBy(c=>c.ClientID).ToList();