Comprobando si un objeto es un diccionario en C#

Question

¿Hay alguna forma de comprobar si un objeto es un diccionario?

En un método estoy tratando de obtener un valor de un elemento seleccionado en un cuadro de lista. En algunas circunstancias, el cuadro de lista puede estar vinculado a un diccionario, pero esto no se conoce en tiempo de compilación.

me gustaría hacer algo similar a esto:

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

¿Hay una manera de hacer esto de forma dinámica en tiempo de ejecución utilizando la reflexión? Sé que es posible usar la reflexión con tipos genéricos y determinar los parámetros de clave/valor, pero no estoy seguro de si hay alguna manera de hacer el resto después de recuperar esos valores.

Answer 1

Debe ser algo como lo siguiente. Escribí esto en el cuadro de respuestas para que la sintaxis no sea exactamente la correcta, pero he hecho que Wiki sea editable para que cualquiera pueda arreglarlo.

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

Comprueba si implementa IDictionary.

Consulte la definición de System.Collections.IDictionary para ver lo que le ofrece.

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

EDIT: Alternativa cuando me di cuenta de KeyValuePair no son moldeables a DictionaryEntry

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

Esta solución utiliza la reflexión, pero en este caso usted no tiene que hacer el trabajo sucio, ListBox lo hace por ti. Además, si generalmente tiene diccionarios como fuentes de datos, puede evitar reiniciar ValueMember todo el tiempo.

Answer 3

Puede ser un poco más genérico y preguntar en su lugar si implementa IDictionary. Luego, la colección de KeyValue contena llana Objects.

Answer 4

puede verificar si implementa IDictionary. Simplemente tendrá que enumerar el uso de la clase DictionaryEntry.

Answer 5

I believe a warning is at place.

Cuando está probando si un objeto "es" algo así o lo otro, está reimplementando (parte de) el sistema de tipos. El primero 'es un' a menudo es seguido rápidamente por otro, y pronto su código está lleno de verificaciones de tipo, que el sistema de tipos debería manejar muy bien, al menos en un diseño orientado a objetos.

Por supuesto, no sé nada del contexto de la pregunta. Conozco a un archivo de línea 2000 en nuestra propia base de código que maneja 50 objeto diferente a la conversión de series ... :(

Answer 6

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

} 

Answer 7

Sé que esta pregunta se le preguntó hace muchos años, pero todavía es visible para el público.

había pocos ejemplos que aquí se proponen en este tema y en éste:
Determine if type is dictionary [duplicate]

pero hay pocos desajustes, así que quiero compartir mi solución

Respuesta corta:

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()))) 

Respuesta más larga:
Creo que esta es la razón por la cual la gente comete errores:

//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 

así que vamos a decir que tenemos estos tipos:

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

y estos casos:

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

por lo que si vamos a utilizar Método .IsAssignableFrom():

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

no vamos a obtener cualquier instancia

así que mejor manera es conseguir todas las interfaces y comprobar si alguno de ellos es la interfaz diccionario:

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