Tuple (o array) come chiavi del dizionario in C #

Sto cercando di creare una tabella di ricerca del dizionario in C #. Ho bisogno di risolvere una tupla di 3 valori in una stringa. Ho provato a usare gli array come chiavi, ma non ha funzionato e non so cos'altro fare. A questo punto sto pensando di creare un dizionario di dizionari di dizionari, ma probabilmente non sarebbe molto carino da guardare, anche se è come lo farei in javascript.

Se sei su .NET 4.0 usa una tupla:

lookup = new Dictionary<Tuple<TypeA, TypeB, TypeC>, string>();

In caso contrario, puoi definire un Tuplee usarlo come chiave. La tupla ha bisogno di ignorare GetHashCode, Equalse IEquatable:

struct Tuple<T, U, W> : IEquatable<Tuple<T,U,W>>
{
    readonly T first;
    readonly U second;
    readonly W third;

    public Tuple(T first, U second, W third)
    {
        this.first = first;
        this.second = second;
        this.third = third;
    }

    public T First { get { return first; } }
    public U Second { get { return second; } }
    public W Third { get { return third; } }

    public override int GetHashCode()
    {
        return first.GetHashCode() ^ second.GetHashCode() ^ third.GetHashCode();
    }

    public override bool Equals(object obj)
    {
        if (obj == null || GetType() != obj.GetType())
        {
            return false;
        }
        return Equals((Tuple<T, U, W>)obj);
    }

    public bool Equals(Tuple<T, U, W> other)
    {
        return other.first.Equals(first) && other.second.Equals(second) && other.third.Equals(third);
    }
}

Tra approcci basati su tupla e dizionari annidati, è quasi sempre meglio optare per basati su tupla.

Dal punto di vista della manutenibilità ,

• è molto più facile implementare una funzionalità simile a:

  var myDict = new Dictionary<Tuple<TypeA, TypeB, TypeC>, string>();

  di

  var myDict = new Dictionary<TypeA, Dictionary<TypeB, Dictionary<TypeC, string>>>();

  dal lato callee. Nel secondo caso ogni aggiunta, ricerca, rimozione, ecc. Richiede un'azione su più di un dizionario.

• Inoltre, se la tua chiave composita richiede un campo in più (o meno) in futuro, dovrai modificare il codice in modo significativo nel secondo caso (dizionario annidato) poiché devi aggiungere ulteriori dizionari annidati e controlli successivi.

Dal punto di vista delle prestazioni , la migliore conclusione che puoi raggiungere è misurarla tu stesso. Ma ci sono alcune limitazioni teoriche che puoi considerare in anticipo:

• Nel caso del dizionario annidato, avere un dizionario aggiuntivo per ogni chiave (esterna e interna) avrà un certo sovraccarico di memoria (più di quello che avrebbe la creazione di una tupla).

• Nel caso del dizionario annidato, ogni azione di base come aggiunta, aggiornamento, ricerca, rimozione, ecc. Deve essere eseguita in due dizionari. Ora c'è un caso in cui l'approccio al dizionario annidato può essere più veloce, cioè quando i dati ricercati sono assenti, poiché i dizionari intermedi possono bypassare il calcolo e il confronto del codice hash completo, ma poi di nuovo dovrebbe essere cronometrato per essere sicuri. In presenza di dati, dovrebbe essere più lento poiché le ricerche dovrebbero essere eseguite due volte (o tre volte a seconda della nidificazione).

• Per quanto riguarda l'approccio tuple, tuple .NET non sono le più performanti quando sono destinati ad essere utilizzati come chiavi in set dal suoi Equalse GetHashCodecause di implementazione di boxe per i tipi di valore .

Vorrei utilizzare un dizionario basato su tupla, ma se voglio maggiori prestazioni, userei la mia tupla con una migliore implementazione.

In una nota a margine, pochi cosmetici possono rendere interessante il dizionario:

1. Le chiamate in stile indicizzatore possono essere molto più pulite e intuitive. Ad esempio,

   string foo = dict[a, b, c]; //lookup
   dict[a, b, c] = ""; //update/insertion

   Quindi esponi gli indicizzatori necessari nella tua classe del dizionario che gestisce internamente gli inserimenti e le ricerche.

2. Inoltre, implementa un'interfaccia adatta IEnumerablee fornisci un Add(TypeA, TypeB, TypeC, string)metodo che fornisca la sintassi dell'inizializzatore della raccolta, come:

   new MultiKeyDictionary<TypeA, TypeB, TypeC, string> 
   { 
       { a, b, c, null }, 
       ...
   };

Se utilizzi C # 7, dovresti considerare l'utilizzo di tuple di valori come chiave composta. Le tuple di valore in genere offrono prestazioni migliori rispetto alle tuple di riferimento tradizionali ( Tuple<T1, …>) poiché le tuple di valore sono tipi di valore (strutture), non tipi di riferimento, quindi evitano i costi di allocazione della memoria e di garbage collection. Inoltre, offrono una sintassi più concisa e intuitiva, consentendo di denominare i loro campi se lo desideri. Implementano anche l' IEquatable<T>interfaccia necessaria per il dizionario.

var dict = new Dictionary<(int PersonId, int LocationId, int SubjectId), string>();
dict.Add((3, 6, 9), "ABC");
dict.Add((PersonId: 4, LocationId: 9, SubjectId: 10), "XYZ");
var personIds = dict.Keys.Select(k => k.PersonId).Distinct().ToList();

I modi buoni, puliti, veloci, facili e leggibili sono:

• generare membri di uguaglianza ( metodo Equals () e GetHashCode ()) per il tipo corrente. Strumenti come ReSharper non solo creano i metodi, ma generano anche il codice necessario per un controllo di uguaglianza e / o per il calcolo del codice hash. Il codice generato sarà più ottimale rispetto alla realizzazione di Tuple.
• basta creare una semplice classe chiave derivata da una tupla .

aggiungi qualcosa di simile come questo:

public sealed class myKey : Tuple<TypeA, TypeB, TypeC>
{
    public myKey(TypeA dataA, TypeB dataB, TypeC dataC) : base (dataA, dataB, dataC) { }

    public TypeA DataA => Item1; 

    public TypeB DataB => Item2;

    public TypeC DataC => Item3;
}

Quindi puoi usarlo con il dizionario:

var myDictinaryData = new Dictionary<myKey, string>()
{
    {new myKey(1, 2, 3), "data123"},
    {new myKey(4, 5, 6), "data456"},
    {new myKey(7, 8, 9), "data789"}
};

• Puoi anche usarlo nei contratti
• come chiave per unirsi o raggruppare in linq
• andando in questo modo non sbaglierai mai a digitare l'ordine di Item1, Item2, Item3 ...
• non è necessario ricordare o esaminare il codice per capire dove andare per ottenere qualcosa
• non è necessario sostituire IStructuralEquatable, IStructuralComparable, IComparable, ITuple tutti già qui

Se per qualche ragione si vuole davvero evitare di creare la propria classe Tuple, o di usarla in .NET 4.0, c'è un altro approccio possibile; puoi combinare i tre valori chiave insieme in un unico valore.

Ad esempio, se i tre valori sono tipi interi insieme che non richiedono più di 64 bit, è possibile combinarli in un file ulong.

Nel peggiore dei casi puoi sempre usare una stringa, purché ti assicuri che i tre componenti in essa contenuti siano delimitati da un carattere o una sequenza che non si trova all'interno dei componenti della chiave, ad esempio, con tre numeri che potresti provare:

string.Format("{0}#{1}#{2}", key1, key2, key3)

C'è ovviamente un sovraccarico di composizione in questo approccio, ma a seconda di cosa lo stai usando per questo potrebbe essere abbastanza banale da non preoccupartene.

Vorrei sovrascrivere la tua tupla con un GetHashCode appropriato e usarlo come chiave.

Finché sovraccarichi i metodi corretti, dovresti vedere prestazioni decenti.

Ecco la tupla .NET per riferimento:

[Serializable] 
public class Tuple<T1, T2, T3> : IStructuralEquatable, IStructuralComparable, IComparable, ITuple {

    private readonly T1 m_Item1; 
    private readonly T2 m_Item2;
    private readonly T3 m_Item3; 

    public T1 Item1 { get { return m_Item1; } }
    public T2 Item2 { get { return m_Item2; } }
    public T3 Item3 { get { return m_Item3; } } 

    public Tuple(T1 item1, T2 item2, T3 item3) { 
        m_Item1 = item1; 
        m_Item2 = item2;
        m_Item3 = item3; 
    }

    public override Boolean Equals(Object obj) {
        return ((IStructuralEquatable) this).Equals(obj, EqualityComparer<Object>.Default);; 
    }

    Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer) { 
        if (other == null) return false;

        Tuple<T1, T2, T3> objTuple = other as Tuple<T1, T2, T3>;

        if (objTuple == null) {
            return false; 
        }

        return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3); 
    }

    Int32 IComparable.CompareTo(Object obj) {
        return ((IStructuralComparable) this).CompareTo(obj, Comparer<Object>.Default);
    }

    Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer) {
        if (other == null) return 1; 

        Tuple<T1, T2, T3> objTuple = other as Tuple<T1, T2, T3>;

        if (objTuple == null) {
            throw new ArgumentException(Environment.GetResourceString("ArgumentException_TupleIncorrectType", this.GetType().ToString()), "other");
        }

        int c = 0;

        c = comparer.Compare(m_Item1, objTuple.m_Item1); 

        if (c != 0) return c; 

        c = comparer.Compare(m_Item2, objTuple.m_Item2);

        if (c != 0) return c; 

        return comparer.Compare(m_Item3, objTuple.m_Item3); 
    } 

    public override int GetHashCode() { 
        return ((IStructuralEquatable) this).GetHashCode(EqualityComparer<Object>.Default);
    }

    Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer) { 
        return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3));
    } 

    Int32 ITuple.GetHashCode(IEqualityComparer comparer) {
        return ((IStructuralEquatable) this).GetHashCode(comparer); 
    }
    public override string ToString() {
        StringBuilder sb = new StringBuilder();
        sb.Append("("); 
        return ((ITuple)this).ToString(sb);
    } 

    string ITuple.ToString(StringBuilder sb) {
        sb.Append(m_Item1); 
        sb.Append(", ");
        sb.Append(m_Item2);
        sb.Append(", ");
        sb.Append(m_Item3); 
        sb.Append(")");
        return sb.ToString(); 
    } 

    int ITuple.Size { 
        get {
            return 3;
        }
    } 
}

Se il tuo codice consumante può accontentarsi di un'interfaccia IDictionary <>, invece di Dictionary, il mio istinto sarebbe stato quello di utilizzare un SortedDictionary <> con un comparatore di array personalizzato, ad esempio:

class ArrayComparer<T> : IComparer<IList<T>>
    where T : IComparable<T>
{
    public int Compare(IList<T> x, IList<T> y)
    {
        int compare = 0;
        for (int n = 0; n < x.Count && n < y.Count; ++n)
        {
            compare = x[n].CompareTo(y[n]);
        }
        return compare;
    }
}

E crea così (usando int [] solo per un esempio concreto):

var dictionary = new SortedDictionary<int[], string>(new ArrayComparer<int>());