C# 如何将字典转换为ConcurrentDictionary？

我已经看过如何转换，但我有一本字典，想转换成ConcurrentDictionary。我该怎么做？。。。更好的是，我可以将link语句设置为ConcurrentDictionary吗

var customers = _customerRepo.Query().Select().ToDictionary(x => x.id, x => x);

使用 它可以接受字典对象，如：

Dictionary<int, string> dictionary = new Dictionary<int, string>();
dictionary.Add(1,"A");
dictionary.Add(2, "B");

ConcurrentDictionary<int,string> concurrentDictionary = 
             new ConcurrentDictionary<int, string>(dictionary);

Dictionary Dictionary=newdictionary（）；
字典.加入（1，“A”）；
增加（2，“B”）；
ConcurrentDictionary ConcurrentDictionary=
新的ConcurrentDictionary（字典）；

我可以将LINQ语句设置为ConcurrentDictionary吗

var customers = _customerRepo.Query().Select().ToDictionary(x => x.id, x => x);

---

不，你不能。。没有扩展方法可用于在LINQ中创建

ConcurrentDictionary

。您可以创建自己的扩展方法，也可以在投影结果时在LINQ查询中使用

ConcurrentDictionary

构造函数

LINQ To Objects语句最终是IEnumerable，因此可以将其传递给ConcurrentDictionary构造函数，例如：

var customers = myCustomers.Select(x => new KeyValuePair(x.id, x));
var dictionary=new ConcurrentDictionary(customers);

这可能不适用于其他提供商。例如，Linq to Entities将整个Linq语句转换为SQL，并且不能投影到KeyValuePair。在这种情况下，您可能需要调用

AsEnumerable（）

或任何其他强制IQueryable执行的方法，例如：

var customers = _customerRepo.Customers.Where(...)
                             .AsEnumerable()
                             .Select(x => new KeyValuePair(x.id, x));
var dictionary=new ConcurrentDictionary(customers);

---

没有参数的

Select（）

不是IEnumerable或IQueryable方法，因此我认为它是由其他ORM提供的方法。如果

Select（）

返回IEnumerable，则可以使用第一个选项，否则可以使用

AsEnumerable（）

为什么不编写自己的扩展方法：

  public static class ConcurrentDictionaryExtensions {
    public static ConcurrentDictionary<TKey, TElement> ToConcurrentDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector, IEqualityComparer<TKey> comparer) {
        if (source == null) throw new ArgumentNullException("source");
        if (keySelector == null) throw new ArgumentNullException("keySelector");
        if (elementSelector == null) throw new ArgumentNullException("elementSelector");

        ConcurrentDictionary<TKey, TElement> d = new ConcurrentDictionary<TKey, TElement>(comparer ?? EqualityComparer<TKey>.Default);
        foreach (TSource element in source)
            d.TryAdd(keySelector(element), elementSelector(element));

        return d;
    }

    public static ConcurrentDictionary<TKey, TSource> ToConcurrentDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) {
        return ToConcurrentDictionary<TSource, TKey, TSource>(source, keySelector, IdentityFunction<TSource>.Instance, null);
    }

    public static ConcurrentDictionary<TKey, TSource> ToConcurrentDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer) {
        return ToConcurrentDictionary<TSource, TKey, TSource>(source, keySelector, IdentityFunction<TSource>.Instance, comparer);
    }

    public static ConcurrentDictionary<TKey, TElement> ToConcurrentDictionary<TSource, TKey, TElement>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector) {
        return ToConcurrentDictionary<TSource, TKey, TElement>(source, keySelector, elementSelector, null);
    }

    internal class IdentityFunction<TElement> {
        public static Func<TElement, TElement> Instance
        {
            get { return x => x; }
        }
    }

}

公共静态类ConcurrentDictionaryExtensions{
公共静态ConcurrentDictionary到ConcurrentDictionary（此IEnumerable源、Func键选择器、Func元素选择器、IEqualityComparer比较器）{
如果（source==null）抛出新的ArgumentNullException（“source”）；
如果（keySelector==null）抛出新的ArgumentNullException（“keySelector”）；
如果（elementSelector==null）抛出新的ArgumentNullException（“elementSelector”）；
ConcurrentDictionary d=新的ConcurrentDictionary（比较器？？EqualityComparer.Default）；
foreach（源中的TSource元素）
d、 TryAdd（键选择器（元素）、元素选择器（元素））；
返回d；
}
公共静态ConcurrentDictionary到ConcurrentDictionary（此IEnumerable源，Func键选择器）{
返回OnCurrentDictionary（source，keySelector，IdentityFunction.Instance，null）；
}
公共静态ConcurrentDictionary到ConcurrentDictionary（此IEnumerable源、Func键选择器、IEqualityComparer比较器）{
返回OnCurrentDictionary（源、键选择器、IdentityFunction.Instance、比较器）；
}
公共静态ConcurrentDictionary到ConcurrentDictionary（此IEnumerable源、Func键选择器、Func元素选择器）{
返回OnCurrentDictionary（source、keySelector、elementSelector、null）；
}
内部类标识函数{
公共静态Func实例
{
获取{return x=>x；}
}
}
}

仅采用了。

中的代码，或仅采用了have方法：

 private ConcurrentDictionary<TKey, TValue> ToConcurrent<TKey, TValue>(Dictionary<TKey, TValue> dic) {
        return new ConcurrentDictionary<TKey, TValue>(dic);
    }

---

就个人而言，我将使用我刚刚更新的扩展方法…

您可以使用LINQ将结果投影到字典中，但您必须编写自己的

到ConcurrentDictionary

扩展方法来完成。（您可能可以摆脱中间字典，直接使用

foreach

插入，并接受键和值选择器委托）。您可以使用LINQ和您提到的构造函数。使用所需的键和值从原始可枚举项创建KeyValuePair，然后将其传递给构造函数，例如

myEnumerable=。。。选择（item=>newkeyvaluepair（item.Id，item）；…新建ConcurrentDictionary（myEnumerable）；

。不需要ForEach，尽管扩展方法会使代码稍微干净您使用的LINQ提供程序是什么？是

Query（）

或

Select（）的结果吗

IQueryable或IEnumerable？请注意，您可以执行

AsEnumerable（）

操作，但这不会造成任何影响。不确定原因，但除非您通过比较器，否则此操作将抛出。请参阅@MotKohn:您是对的。根据