Accès insensible à la casse pour le dictionnaire générique

J'ai une application qui utilise des DLL gérées. Une de ces DLL renvoie un dictionnaire générique:

Dictionary<string, int> MyDictionary;  

Le dictionnaire contient des touches avec majuscules et minuscules.

D'un autre côté, je reçois une liste de clés potentielles (chaîne) mais je ne peux pas garantir le cas. J'essaye d'obtenir la valeur dans le dictionnaire en utilisant les clés. Mais bien sûr, ce qui suit échouera car j'ai une incompatibilité de cas:

bool Success = MyDictionary.TryGetValue( MyIndex, out TheValue );  

J'espérais que TryGetValue aurait un indicateur de casse ignoré comme mentionné dans la doc MSDN , mais il semble que ce ne soit pas valide pour les dictionnaires génériques.

Existe-t-il un moyen d'obtenir la valeur de ce dictionnaire en ignorant le cas clé? Existe-t-il une meilleure solution de contournement que la création d'une nouvelle copie du dictionnaire avec le paramètre StringComparer.OrdinalIgnoreCase approprié ?

Il n'y a aucun moyen de spécifier un StringComparerau point où vous essayez d'obtenir une valeur. Si vous y pensez "foo".GetHashCode()et "FOO".GetHashCode()êtes totalement différent, il n'y a donc aucun moyen raisonnable d'implémenter un get insensible à la casse sur une carte de hachage sensible à la casse.

Vous pouvez, cependant, créer un dictionnaire insensible à la casse en premier lieu en utilisant: -

var comparer = StringComparer.OrdinalIgnoreCase;
var caseInsensitiveDictionary = new Dictionary<string, int>(comparer);

Ou créez un nouveau dictionnaire ne respectant pas la casse avec le contenu d'un dictionnaire sensible à la casse existant (si vous êtes sûr qu'il n'y a pas de collision de cas): -

var oldDictionary = ...;
var comparer = StringComparer.OrdinalIgnoreCase;
var newDictionary = new Dictionary<string, int>(oldDictionary, comparer);

Ce nouveau dictionnaire utilise alors l' GetHashCode()implémentation StringComparer.OrdinalIgnoreCaseainsi comparer.GetHashCode("foo")et comparer.GetHashcode("FOO")vous donne la même valeur.

Alternativement, s'il n'y a que quelques éléments dans le dictionnaire, et / ou que vous n'avez besoin de chercher qu'une ou deux fois, vous pouvez traiter le dictionnaire d'origine comme un IEnumerable<KeyValuePair<TKey, TValue>>et simplement le parcourir: -

var myKey = ...;
var myDictionary = ...;
var comparer = StringComparer.OrdinalIgnoreCase;
var value = myDictionary.FirstOrDefault(x => String.Equals(x.Key, myKey, comparer)).Value;

Ou si vous préférez, sans LINQ: -

var myKey = ...;
var myDictionary = ...;
var comparer = StringComparer.OrdinalIgnoreCase;
int? value;
foreach (var element in myDictionary)
{
  if (String.Equals(element.Key, myKey, comparer))
  {
    value = element.Value;
    break;
  }
}

Cela vous évite le coût de création d'une nouvelle structure de données, mais en retour, le coût d'une recherche est O (n) au lieu de O (1).

Pour vous LINQers là-bas qui n'utilisez jamais un constructeur de dictionnaire ordinaire:

myCollection.ToDictionary(x => x.PartNumber, x => x.PartDescription, StringComparer.OrdinalIgnoreCase)

Ce n'est pas très élégant mais au cas où vous ne pouvez pas changer la création du dictionnaire, et tout ce dont vous avez besoin est un hack sale, que diriez-vous:

var item = MyDictionary.Where(x => x.Key.ToLower() == MyIndex.ToLower()).FirstOrDefault();
    if (item != null)
    {
        TheValue = item.Value;
    }