Dostęp bez rozróżniania wielkości liter do słownika ogólnego

Mam aplikację korzystającą z zarządzanych bibliotek DLL. Jedna z tych bibliotek dll zwraca ogólny słownik:

Dictionary<string, int> MyDictionary;  

Słownik zawiera klawisze z dużymi i małymi literami.

Z drugiej strony otrzymuję listę potencjalnych kluczy (ciągów), ale nie mogę zagwarantować sprawy. Próbuję uzyskać wartość w słowniku za pomocą klawiszy. Ale oczywiście nie powiedzie się, ponieważ mam niedopasowanie wielkości liter:

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

Miałem nadzieję, że TryGetValue będzie miał flagę ignorowania przypadków, jak wspomniano w dokumencie MSDN , ale wydaje się, że nie jest to poprawne w przypadku ogólnych słowników.

Czy istnieje sposób, aby uzyskać wartość tego słownika ignorując kluczową wielkość liter? Czy istnieje lepsze obejście niż tworzenie nowej kopii słownika z odpowiednim parametrem StringComparer.OrdinalIgnoreCase ?

Nie ma sposobu, aby określić StringComparerpunkt, w którym próbujesz uzyskać wartość. Jeśli się nad tym zastanowić "foo".GetHashCode()i "FOO".GetHashCode()są zupełnie inni, nie ma rozsądnego sposobu na wprowadzenie rozróżniania wielkości liter na mapie mieszającej uwzględniającej wielkość liter.

Możesz jednak przede wszystkim utworzyć słownik bez rozróżniania wielkości liter, używając:

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

Lub utwórz nowy słownik bez rozróżniania wielkości liter z zawartością istniejącego słownika z rozróżnianiem wielkości liter (jeśli masz pewność, że nie występują kolizje wielkości liter): -

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

Ten nowy słownik używa następnie GetHashCode()implementacji StringComparer.OrdinalIgnoreCaseso comparer.GetHashCode("foo")i comparer.GetHashcode("FOO")daje tę samą wartość.

Alternatywnie, jeśli w słowniku jest tylko kilka elementów i / lub potrzebujesz tylko raz lub dwa razy wyszukać, możesz traktować oryginalny słownik jako IEnumerable<KeyValuePair<TKey, TValue>>i po prostu iterować:

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

Lub jeśli wolisz, bez 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;
  }
}

Oszczędza to kosztów tworzenia nowej struktury danych, ale w zamian kosztem wyszukiwania jest O (n) zamiast O (1).

Dla was LINQers, którzy nigdy nie używają zwykłego konstruktora słownika:

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

Nie jest zbyt elegancki, ale na wypadek, gdybyś nie mógł zmienić tworzenia słownika, a wszystko, czego potrzebujesz, to brudny hack, co powiesz na to:

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