Инициализация поиска <int, string>

Ответ 1

В документации MSDN нет открытого конструктора для класса Lookup: http://msdn.microsoft.com/en-us/library/bb460184.aspx

Вы можете создать экземпляр Lookup<TKey, TElement>, вызвав ToLookup для объекта, который реализует IEnumerable<T>.

Вам нужно сделать что-то вроде:

new Component {ID = 1, Name = "MOBO", Category = new[] { ..... }.ToLookup(...) }

Обновить для комментариев:

Я не уверен, откуда вы получаете информацию о своей категории, поэтому я что-то сделаю...

new Component {
    ID = 1, 
    Name = "MOBO", 
    Category = new Dictionary<int, string>{ 
        {3, "Beverages"}
        {5, "Produce"}
    }.ToLookup(o => o.Key, o => o.Value)
}

Я предполагаю, что ваши категории будут исходить из какого-то другого источника вместо создания экземпляра словаря, как я здесь.

Ответ 2

От MSDN:

Нет никакого публичного конструктора для создания нового экземпляра Lookup<TKey, TElement>.
Кроме того, объекты Lookup<TKey, TElement> неизменяемы, то есть вы не можете добавлять или удалять элементы или ключи из объекта Lookup<TKey, TElement> после его создания.

Ответ 3

Вы не можете просто использовать ToLookup; вы должны сказать ему, как найти ключи и значения:

// from ChaosPandion code
using System.Linq; // make sure you have the using statement 

var component = new Component()  
{  
    ID = 1,  
    Name = "MOBO",  
    Category = (Lookup<int, string>)
       (new Dictionary<int, string>() { {1, "one"} })
       .ToLookup(p=>p.Key, p=>p.Value)
}  

Я не понимаю, почему вы хотите использовать Lookup здесь вместо словаря.

Ответ 4

Вот моя попытка по этому поводу. Убедитесь, что ключ неизменен (Gist).

public class MultiValueDictionary<TKey, TElement>
: Collection<TElement>, ILookup<TKey, TElement>
{
  public MultiValueDictionary(Func<TElement, TKey> keyForItem)
    : base(new Collection(keyForItem))
  {
  }

  new Collection Items => (Collection)base.Items;

  public IEnumerable<TElement> this[TKey key] => Items[key];
  public bool Contains(TKey key) => Items.Contains(key);
  IEnumerator<IGrouping<TKey, TElement>>
    IEnumerable<IGrouping<TKey, TElement>>.GetEnumerator() => Items.GetEnumerator();

  class Collection
  : KeyedCollection<TKey, Grouping>, IEnumerable<TElement>, IList<TElement>
  {
    Func<TElement, TKey> KeyForItem { get; }

    public Collection(Func<TElement, TKey> keyForItem) => KeyForItem = keyForItem;
    protected override TKey GetKeyForItem(Grouping item) => item.Key;

    public void Add(TElement item)
    {
      var key = KeyForItem(item);
      if (Dictionary != null && Dictionary.TryGetValue(key, out var collection))
        collection.Add(item);
      else
        Add(new Grouping(key) { item });
    }

    public bool Remove(TElement item)
    {
      var key = KeyForItem(item);
      if (Dictionary != null && Dictionary.TryGetValue(key, out var collection)
        && collection.Remove(item))
      {
        if (collection.Count == 0)
          Remove(key);
        return true;
      }
      return false;
    }

    IEnumerator<TElement> IEnumerable<TElement>.GetEnumerator()
    {
      foreach (var group in base.Items)
        foreach (var item in group)
          yield return item;
    }

    const string IndexError = "Indexing not supported.";
    public int IndexOf(TElement item) => throw new NotSupportedException(IndexError);
    public void Insert(int index, TElement item) => Add(item);
    public bool Contains(TElement item) => Items.Contains(item);
    public void CopyTo(TElement[] array, int arrayIndex) =>
    throw new NotSupportedException(IndexError);
    new IEnumerable<TElement> Items => this;
    public bool IsReadOnly => false;
    TElement IList<TElement>.this[int index]
    {
      get => throw new NotSupportedException(IndexError);
      set => throw new NotSupportedException(IndexError);
    }
  }

  class Grouping : Collection<TElement>, IGrouping<TKey, TElement>
  {
    public Grouping(TKey key) => Key = key;
    public TKey Key { get; }
  }
}