按距离对位于同一位置的服务器列表进行排序

有趣的问题。我不知道这是否可以以一种优雅的方式完成，但是您可以将groupByDistance传递给这样的方法:

IEnumerable<Server> Zip(IEnumerable<IEnumerable<Server>> groups)
{
    bool cont;
    int i = 0;
    do
    {
        cont = false;
        foreach (var grp in groups)
        {
            var element = grp.Skip(i).FirstOrDefault();
            if (element != null)
            {
                cont = true;
                yield return element;
            }
        }
        ++i;
    } while (cont);
}

将返回一个IEnumerable，因此如果需要，它可以在进一步的LINQ查询中使用。它还具有延迟枚举的特性。但是——它绝对不优雅。

我的完整的沙盒来尝试这个，//option2是你的选择:

using System.Collections.Generic;
using System.Linq;
namespace LinqTest01
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Server> servers = new List<Server>{
                new Server(){ load = null, distance = 3 },
                new Server(){ load = 0.1, distance = 3 },
                new Server(){ load = 0.6, distance = 3 },
                new Server(){ load = 0.2, distance = 3 },
                new Server(){ load = 0.7, distance = 1 },
                new Server(){ load = 0.1, distance = 1 },
                new Server(){ load = 0.2, distance = 1 },
                new Server(){ load = 0.1, distance = 2 },
                };
            // option 1
            var sorted = from server in servers orderby server.load where server.load != null select server;
            var groups = from server in sorted
                       group server by server.distance into bydistance
                       orderby bydistance.Key
                       select bydistance
                       ;
            var final1 = Zip(groups);
            // option 2
            var orderedbyLoad = servers.OrderBy(t => t.load);
            var groupByDistance = orderedbyLoad.GroupBy(a => a.distance, s => s);
            var final2 = Zip(groups);
        }
        static IEnumerable<Server> Zip(IEnumerable<IEnumerable<Server>> groups)
        {
            bool cont;
            int i = 0;
            do
            {
                cont = false;
                foreach (var grp in groups)
                {
                    var element = grp.Skip(i).FirstOrDefault();
                    if (element != null)
                    {
                        cont = true;
                        yield return element;
                    }
                }
                ++i;
            } while (cont);
        }
    }
    class Server
    {
        public double? load;
        public int distance;
    }
}

你为什么不试试这样做呢?

作为servers的原始(非分组)服务器列表:

servers.Where(x => x.Load != null).OrderBy(x => x.Load).ThenBy(x => x.Distance)

如果我没理解错的话，这应该会给你一个列表，按照最近的距离排序，然后是最小的负载。

如果你想把"null loads"添加到列表的末尾:

servers.Where(x => x.Load != null).OrderBy(x => x.Load).ThenBy(x => x.Distance).Concat(servers.Where(x => x.Load == null))

这是你想要达到的目标吗?

编辑:那一个没有尊重组之间的确切顺序。为了实现您应该"手动"遍历每个组，使用此代码和您的测试用例，我得到了预期的结果:

        List<Server> serversList = new List<Server>();
        serversList.Add(new Server { Name = "S1", Location = "LOC1", Distance = 3, Load = null });
        serversList.Add(new Server { Name = "S2", Location = "LOC1", Distance = 3, Load = 1 });
        serversList.Add(new Server { Name = "S3", Location = "LOC1", Distance = 3, Load = 6 });
        serversList.Add(new Server { Name = "S4", Location = "LOC1", Distance = 3, Load = 2 });
        serversList.Add(new Server { Name = "S1", Location = "LOC2", Distance = 1, Load = 7 });
        serversList.Add(new Server { Name = "S2", Location = "LOC2", Distance = 1, Load = 1 });
        serversList.Add(new Server { Name = "S3", Location = "LOC2", Distance = 1, Load = 2 });
        serversList.Add(new Server { Name = "S1", Location = "LOC3", Distance = 2, Load = 1 });
        List<Server> orderedList = new List<Server>();
        var serversByDistance = serversList.Where(x => x.Load != null)
            .OrderBy(x => x.Distance)
            .GroupBy(x => x.Distance)
            .ToDictionary(x => x.Key, x => x.OrderBy(s => s.Load).ToList());
        for (int i = 0; i < serversByDistance.Values.Max(x => x.Count); i++)
        {
            foreach (var key in serversByDistance.Keys)
            {
                var element = serversByDistance[key].ElementAtOrDefault(i);
                if (element != null)
                    orderedList.Add(element);
            }
        }

如果需要，可以将null结果添加到orderedList。

(注意:为了简单起见，我使用int类型进行测试…P)