创建ILookup< int, int>从IDictionary< int, IEnumerable< int>祝辞

本文关键字：int IEnumerable 祝辞 IDictionary ILookup 创建 | 更新日期: 2023-09-27 18:15:22

有没有什么优雅的方法来转换

IDictionary<int, IEnumerable<int>> into ILookup<int,int> ?据我所知，它应该是相同的，但我发现查找更清楚。

背后的故事更复杂，但我被迫选择id列表及其相关id列表:

masters
    .Select(m => new {masterId = m.Id, childIds = m.Children.Select(c => c.Id)})
    .ToDictionary(k => masterId, v => v.childIds)

我很乐意选择直接查找，但我不知道这是否可能。

主变量类型的例子可以简单如下:

public class Master
{
     public int Id { get; set; }
     public List<Master> Children { get; set; }
}

创建ILookup< int, int>从IDictionary< int, IEnumerable< int>祝辞

正如Lasse V. Karlsen在评论中建议的那样，您可以创建一个暴露ILookup的包装器类型:

public class LookupDictionary<TKey, TElement> : ILookup<TKey, TElement>
{
    private readonly IDictionary<TKey, IEnumerable<TElement>> _dic;
    public LookupDictionary(IDictionary<TKey, IEnumerable<TElement>> dic)
    {
        _dic = dic;
    }
    public int Count
    {
        get { return _dic.Values.Sum(x => x.Count()); }
    }
    public IEnumerable<TElement> this[TKey key]
    {
        get { return _dic.ContainsKey(key) ? _dic[key] : Enumerable.Empty<TElement>(); }
    }
    public bool Contains(TKey key)
    {
        return _dic.ContainsKey(key);
    }
    public IEnumerator<IGrouping<TKey, TElement>> GetEnumerator()
    {
        return _dic.Select(kv => new LookupDictionaryGrouping(kv)).GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    class LookupDictionaryGrouping : IGrouping<TKey, TElement>
    {
        private KeyValuePair<TKey, IEnumerable<TElement>> _kvp;
        public TKey Key
        {
            get { return _kvp.Key; }
        }
        public IEnumerator<TElement> GetEnumerator()
        {
            return _kvp.Value.GetEnumerator();
        }
        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
        public LookupDictionaryGrouping(KeyValuePair<TKey, IEnumerable<TElement>> kvp)
        {
            _kvp = kvp;
        }
    }
}

嗯，你可以将字典平放，然后将其转换为Lookup:

dict.SelectMany(kvp -> kvp.Value, (kvp, v) => new {k = kvp.Key, v})
    .ToLookup(kvp => kvp.k, kvp => kvp.v)

但是它实际上和字典是一样的所以它似乎没有必要

如果我没理解错的话，你是想让你的收藏变平。你可以这样做:

masters.SelectMany(x => x.Children, (x, y) 
   => new { 
            ParentId = x.Id, 
            ChildId = y.Id 
          })
   .ToLookup(x => x.ParentId, y => y.ChildId);

你会得到你的ILookup<int,int>。此外，您不需要任何Dictionary集合。但是使用Dictionary是非常安全的。

您可以这样做-比纯lambda更具可读性…:) 

Dictionary<int, IEnumerable<int>> dict = new Dictionary<int, IEnumerable<int>>();
dict.Add(1, new int[] {1, 2, 3});
dict.Add(2, new int[] {4, 5, 6});
dict.Add(3, new int[] {4, 5, 6});
var lookup = (from kv in dict
            from v in kv.Value
            select new KeyValuePair<int, int>(kv.Key, v)).ToLookup(k=>k.Key, v=>v.Value);
相关文章：