Inicializando la búsqueda <int, string>

Question

¿Cómo declaro una nueva clase de búsqueda para una propiedad en la rutina de inicialización de objetos en C#?

E.g.

new Component() { ID = 1, Name = "MOBO", Category = new Lookup<int, string> } 

La categoría bit siempre obtiene un error de compilación.

---

que tienen una propiedad llamada Category que es del tipo Lookup<int, string> y quiero crear una instancia de esta propiedad a través de

new Component() { ID = 1, Name = "MOBO", Category = new Lookup<int, string> }; 

pero no puedo conseguir más allá de los errores de compilación.

Answer 1

De MSDN:

No hay constructor público para crear una nueva instancia de un Lookup<TKey, TElement>.
Además, los objetos Lookup<TKey, TElement> son inmutables, es decir, no se pueden agregar o eliminar elementos o claves de un objeto Lookup<TKey, TElement> después de que se haya creado.

Answer 2

por documentación de MSDN, no hay ningún constructor público para la clase Lookup: http://msdn.microsoft.com/en-us/library/bb460184.aspx

puede crear una instancia de un Lookup<TKey, TElement> llamando ToLookup sobre un objeto que implementa IEnumerable<T>.

Usted tendrá que hacer algo como:

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

actualización para resolver los comentarios:

No estoy seguro de donde está recibiendo su categoría de información, por lo que va a hacer algo ...

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

Supongo que sus categorías vendrán de alguna otra fuente en lugar de crear un diccionario como lo hice aquí.

Answer 3

No puede usar ToLookup; usted tiene que decirle cómo encontrar las claves y valores:

// from ChaosPandion's 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) 
} 

No entiendo por qué desea utilizar una búsqueda aquí en lugar de un diccionario, sin embargo.

Answer 4

Aquí está mi intento de esto. Asegúrese de que la clave sea inmutable (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; } 
    } 
}