我的工作假设是LINQ在与System.Collections.Concurrent集合（包括ConcurrentDictionary）一起使用时是线程安全的。
（其他溢出帖子似乎也同意：link）
但是，对LINQOrderBy扩展方法实现的检查表明，对于实现ICollection的并发集合子集（例如，ConcurrentDictionary），它似乎不是线程安全的。

• • OrderedEnumerable****GetEnumerator**（此处为源代码）构造Buffer结构（此处为源代码）的示例，该示例尝试将集合强制转换为ICollection（ConcurrentDictionary实现），然后使用初始化为集合大小的数组执行collection.CopyTo。

因此，如果ConcurrentDictionary（在本例中为具体的ICollection）在OrderBy操作期间（初始化数组和复制到数组之间）大小增加，则此操作将引发。
以下测试代码显示了此异常：
(Note：我知道在线程安全的集合上执行OrderBy并没有什么意义，但我认为它不应该引发）

using System;
using System.Collections.Concurrent;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace Program
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                int loop = 0;
                while (true) //Run many loops until exception thrown
                {
                    Console.WriteLine($"Loop: {++loop}");

                    _DoConcurrentDictionaryWork().Wait();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }

        private static async Task _DoConcurrentDictionaryWork()
        {
            var concurrentDictionary = new ConcurrentDictionary<int, object>();
            var keyGenerator = new Random();
            var tokenSource = new CancellationTokenSource();

            var orderByTaskLoop = Task.Run(() =>
            {
                var token = tokenSource.Token;
                while (token.IsCancellationRequested == false)
                {
                    //Keep ordering concurrent dictionary on a loop
                    var orderedPairs = concurrentDictionary.OrderBy(x => x.Key).ToArray(); //THROWS EXCEPTION HERE

                    //...do some more work with ordered snapshot...
                }
            });

            var updateDictTaskLoop = Task.Run(() =>
            {
                var token = tokenSource.Token;
                while (token.IsCancellationRequested == false)
                {
                    //keep mutating dictionary on a loop
                    var key = keyGenerator.Next(0, 1000);
                    concurrentDictionary[key] = new object();
                }
            });

            //Wait for 1 second
            await Task.Delay(TimeSpan.FromSeconds(1));

            //Cancel and dispose token
            tokenSource.Cancel();
            tokenSource.Dispose();

            //Wait for orderBy and update loops to finish (now token cancelled)
            await Task.WhenAll(orderByTaskLoop, updateDictTaskLoop);
        }
    }
}

• • OrderBy**抛出异常会导致以下几个可能的结论之一：

1)我关于LINQ对于并发集合是线程安全的假设是不正确的，只有在LINQ查询过程中不发生变化的集合（无论是否并发）上执行LINQ才是安全的
2)LINQOrderBy的实现存在缺陷，该实现尝试将源集合强制转换为ICollection并尝试执行集合复制是不正确的（它应直接进入其迭代IEnumerable的默认行为）。
3)我误解了这里发生的事...
非常感谢!