Testen, ob ein Objekt ein Dictionary in C ist

Question

Gibt es eine Möglichkeit zu testen, ob ein Objekt ein Wörterbuch ist?

In einer Methode versuche ich, einen Wert von einem ausgewählten Element in einer Listbox zu erhalten. Unter bestimmten Umständen ist das Listenfeld möglicherweise an ein Wörterbuch gebunden, das ist jedoch zur Kompilierzeit nicht bekannt.

Ich möchte etwas ähnliches wie dies tun:

if (listBox.ItemsSource is Dictionary<??>) 
{ 
    KeyValuePair<??> pair = (KeyValuePair<??>)listBox.SelectedItem; 
    object value = pair.Value; 
} 

Gibt es eine Möglichkeit, dies zur Laufzeit mit Reflexion dynamisch zu tun? Ich weiß, dass es möglich ist, Reflektionen mit generischen Typen zu verwenden und die Schlüssel/Wert-Parameter zu bestimmen, aber ich bin mir nicht sicher, ob es eine Möglichkeit gibt, den Rest zu machen, nachdem diese Werte abgerufen wurden.

Answer 1

Es sollte so etwas wie folgt sein. Ich habe dies in die Antwortbox geschrieben, so dass die Syntax möglicherweise nicht genau stimmt, aber ich habe es in Wiki editierbar gemacht, damit jeder etwas reparieren kann.

if (listBox.ItemsSource.IsGenericType && 
    typeof(IDictionary<,>).IsAssignableFrom(listBox.ItemsSource.GetGenericTypeDefinition())) 
{ 
    var method = typeof(KeyValuePair<,>).GetProperty("Value").GetGetMethod(); 
    var item = method.Invoke(listBox.SelectedItem, null); 
} 

Answer 2

Überprüfen Sie, ob es IDictionary implementiert.

Siehe die Definition von System.Collections.IDictionary, um zu sehen, was Ihnen das gibt.

if (listBox.ItemsSource is IDictionary) 
{ 
    DictionaryEntry pair = (DictionaryEntry)listBox.SelectedItem; 
    object value = pair.Value; 
} 

EDIT: Alternative, als ich erkannte KeyValuePair ist zu Dictionary nicht gießbar sind

if (listBox.DataSource is IDictionary) 
{ 
    listBox.ValueMember = "Value"; 
    object value = listBox.SelectedValue; 
    listBox.ValueMember = ""; //If you need it to generally be empty. 
} 

Diese Lösung Reflexion verwendet, aber in diesem Fall müssen Sie die Grunzen Arbeit nicht tun, ListBox macht es für Sie. Auch wenn Sie in der Regel Wörterbücher als Datenquellen haben, können Sie möglicherweise verhindern, dass ValueMember die ganze Zeit zurückgesetzt wird.

Answer 3

Sie könnten etwas generischer sein und stattdessen fragen, ob es IDictionary implementiert. Dann wird die KeyValue-Kollektion contina plain Objects.

Answer 4

können Sie prüfen, ob es IDictionary implementiert. Sie müssen nur über die DictionaryEntry Klasse aufzählen.

Answer 5

Ich glaube eine Warnung ist am Platz.

Wenn Sie testen, ob ein Objekt "etwas" ist, implementieren Sie (teilweise) das Typsystem. Auf das erste "ist ein" folgt oft schnell ein zweites, und bald ist Ihr Code voll von Typ-Checks, die vom Typsystem - zumindest in einem objektorientierten Design - sehr gut gehandhabt werden sollten.

Natürlich weiß ich nichts über den Kontext der Frage. Ich weiß, eine 2000 Linie Datei in unserer eigenen Code-Basis, die String Konvertierungen 50 verschiedene Objekt-Handles ... :(

Answer 6

if(typeof(IDictionary).IsAssignableFrom(listBox.ItemsSource.GetType())) 
{ 

} 

Answer 7

Ich weiß, diese Frage vor vielen Jahren gefragt wurde, aber es ist öffentlich noch sichtbar.

Es gab hier einige Beispiele in diesem Thema vorgeschlagen und in dieser:
Determine if type is dictionary [duplicate]

aber es gibt nur wenige Mismatches, so dass ich möchte, dass meine Lösung teilen

Kurze Antwort:

var dictionaryInterfaces = new[] 
{ 
    typeof(IDictionary<,>), 
    typeof(IDictionary), 
    typeof(IReadOnlyDictionary<,>), 
}; 

var dictionaries = collectionOfAnyTypeObjects 
    .Where(d => d.GetType().GetInterfaces() 
     .Any(t=> dictionaryInterfaces 
      .Any(i=> i == t || t.IsGenericType && i == t.GetGenericTypeDefinition()))) 

Längere Antwort:
Ich glaube, dies ist der Grund, warum Menschen machen Fehler:

//notice the difference between IDictionary (interface) and Dictionary (class) 
typeof(IDictionary<,>).IsAssignableFrom(typeof(IDictionary<,>)) // true 
typeof(IDictionary<int, int>).IsAssignableFrom(typeof(IDictionary<int, int>)); // true 

typeof(IDictionary<int, int>).IsAssignableFrom(typeof(Dictionary<int, int>)); // true 
typeof(IDictionary<,>).IsAssignableFrom(typeof(Dictionary<,>)); // false!! in contrast with above line this is little bit unintuitive 

so lassen sagen, dass wir diese Art haben:

public class CustomReadOnlyDictionary : IReadOnlyDictionary<string, MyClass> 
public class CustomGenericDictionary : IDictionary<string, MyClass> 
public class CustomDictionary : IDictionary 

und diese Instanzen:

var dictionaries = new object[] 
{ 
    new Dictionary<string, MyClass>(), 
    new ReadOnlyDictionary<string, MyClass>(new Dictionary<string, MyClass>()), 
    new CustomReadOnlyDictionary(), 
    new CustomDictionary(), 
    new CustomGenericDictionary() 
}; 

also, wenn wir verwenden .IsAssignableFrom() Methode:

var dictionaries2 = dictionaries.Where(d => 
    { 
     var type = d.GetType(); 
     return type.IsGenericType && typeof(IDictionary<,>).IsAssignableFrom(type.GetGenericTypeDefinition()); 
    }); // count == 0!! 

wir jede Instanz nicht bekommen

so beste Weg ist, alle Schnittstellen zu bekommen und überprüfen, ob einer von ihnen Wörterbuch-Schnittstelle ist:

var dictionaryInterfaces = new[] 
{ 
    typeof(IDictionary<,>), 
    typeof(IDictionary), 
    typeof(IReadOnlyDictionary<,>), 
}; 

var dictionaries2 = dictionaries 
    .Where(d => d.GetType().GetInterfaces() 
     .Any(t=> dictionaryInterfaces 
      .Any(i=> i == t || t.IsGenericType && i == t.GetGenericTypeDefinition()))) // count == 5