创建 Ilookup<int,int> 来自 IDictionary <int,IEnumerable<int> &gt;

Question

Is there any elegant way how to transform

IDictionary<int, IEnumerable<int>> into ILookup<int,int> ? As far as I know it should be identical, but I find lookups to be more clear.

Story behind this is more complex but I'm forced to select List of ids together with its Lists of related ids:

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

I would be happy to select directly Lookup but I don't know if its possible.

example of master variable type can be simple as this:

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

Answer 1

As Lasse V. Karlsen suggested in the comments, you could create a wrapper type that exposes an 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;
        }
    }
}

Answer 2

Well, you could flatten the dictionary and then convert it to a Lookup :

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

but it's practically the same thing as a dictionary so it seems unnecessary.

Answer 3

If I understand you correctly you want to flatten your collection. You can do it like this:

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

So you'll get your ILookup<int,int> . Moreover, you don't need any Dictionary collection. But it' pretty much safe with Dictionary .

Answer 4

You could do this - a bit more readable than pure lambdas... :)

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);