Tester si un objet est un dictionnaire en C #

Est-il un moyen de tester si un objet est un dictionnaire?

Dans une méthode que je suis en train d'essayer de récupérer la valeur d'un élément sélectionné dans une liste déroulante. Dans certains cas, la zone de liste peut être lié à un dictionnaire, mais ce n'est pas connu au moment de la compilation.

Je voudrais faire quelque chose de similaire à ceci:

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

Est-il un moyen de le faire dynamiquement lors de l'exécution à l'aide de la réflexion? Je sais qu'il est possible d'utiliser la réflexion avec les types génériques et de déterminer la clé/valeur des paramètres, mais je ne sais pas si il existe un moyen de faire le reste, après ces valeurs sont extraites.

source d'informationauteur Bob Wintemberg

  1. 10

    Il devrait être quelque chose comme ce qui suit. J'ai écrit cela dans la réponse de la boîte de sorte que la syntaxe peut-être pas exactement, mais je l'ai fait, Wiki éditable donc n'importe qui peut réparer.

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

    Vérifier pour voir si elle met en œuvre IDictionary.

    Voir la définition de Système.Les Collections.IDictionary pour voir ce que ça donne.

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

    EDIT:
    Alternative quand j'ai réalisé KeyValuePair ne sont pas moulage à DictionaryEntry

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

    Cette solution utilise la réflexion, mais dans ce cas, vous n'avez pas à faire la basse besogne, ListBox fait pour vous. Aussi, si vous avez généralement des dictionnaires en tant que sources de données que vous pouvez être en mesure d'éviter de mettre à zéro ValueMember de tous les temps.

  3. 3

    Je sais que cette question a été posée de nombreuses années il ya, mais il est encore visible publiquement.

    Il existe peu d'exemples proposés ici dans cette rubrique et dans celui-ci:

    Déterminer si le type est dictionnaire [dupliquer]

    mais il y a quelques décalages, donc, je veux partager ma solution

    Réponse courte:

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

    Plus réponse:

    Je crois que c'est la raison pourquoi les gens font des erreurs:

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

    donc, disons que nous avons de ces types:

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

    et ces instances:

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

    donc, si nous allons utiliser .IsAssignableFrom() méthode:

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

    nous n'allons pas entrer n'importe quelle instance

    donc, la meilleure façon est d'obtenir toutes les interfaces et vérifier si l'un d'entre eux est l'interface du dictionnaire:

    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
  4. 1

    vous pouvez vérifier pour voir si elle met en œuvre IDictionary. Vous aurez juste à les énumérer sur l'aide de la DictionaryEntry classe.

  5. 0

    Vous pourriez être un peu plus générique et de demander à la place, si elle met en œuvre IDictionary. Puis le KeyValue collection contina plaine Objects.

  6. 0

    Je crois qu'un avertissement est à la place.

    Lorsque vous êtes tester si un objet est un " quelque chose de ceci ou de cela, vous êtes de réimplanter (en partie) le type de système. Le premier est un " est souvent rapidement suivi par un second, et bientôt votre code est plein de type de contrôles, qui doit être très bien pris en compte par le système de type - au moins dans une conception orientée objet.

    Bien sûr, je ne connais pas le contexte de la question. Je ne connais 2000 ligne de fichiers dans notre base de code qui gère les 50 objets différents de la Chaîne de conversions... 🙁

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

}