L'obtention d'un objet à partir d'un dictionnaire d'objets

Je suis en train de tirer un objet à partir d'un dictionnaire d'objets, et de retour de l'objet cependant, je vais avoir un peu d'un problème avec les types. La classe en question ressemble à quelque chose comme ça, je me demande comment j'ai procéder pour retourner l'objet réel plutôt que de la variable (qui je suppose est une chaîne de caractères par défaut).

 public Object GetObject(string foo){

 if(someDict.ContainsKey(foo))
 {
   var pulledObject = someDict[foo];

 }
  return pulledObject;
 }

J'avais pensé que la boxe était nécessaire, quelque chose comme

 object pulledObject = someDict[foo];

Mais cela ne semble pas fonctionner, tout conseil qui pourrait m'indiquer la bonne direction.

Que devrait-il retourner si la clé n'existe pas?
Vous avez un champ d'application-problème. Vous êtes à la déclaration de vos pulledObject à l'intérieur de la si-déclaration de la portée, ce qui le rend inaccessible à l'extérieur pour votre retour-déclaration de travail.
Êtes-vous d'obtenir une erreur de compilation ou le programme de dysfonctionnement lors de l'exécution? "ne fonctionne pas" est un peu vague.

OriginalL'auteur cosmicsafari | 2012-11-06

  1. 8

    Vous n'avez pas vraiment dire ce qui n'est pas le travail, mais vous êtes sur la bonne voie. Essayez quelque chose comme ceci:

    public Object GetObject(string foo){

  if (someDict.ContainsKey(foo))
    return someDict[foo];
  return null;
}

    Je pensez que votre problème est que vous receviez une erreur de compilation avec pulledObject qui était dans un enfant.

    Mise à jour: Comme Jon Skeet points, il est même préférable d'utiliser TryGetValue afin de ne pas effectuer la recherche à deux reprises (une fois lors ContainsKey, et à nouveau lorsque vous utilisez l'indexeur []). Donc, la meilleure solution est:

    public Object GetObject(string foo){

  object pulledObject = null;
  someDict.TryGetValue(foo, out pulledObject);
  return pulledObject;
}
    Mieux utiliser TryGetValue...
    quelle est la différence entre l'utilisation de ContainsKey et TryGetValue? La question est purement académique.
    Avec TryGetValue, vous avez seulement besoin de faire de la recherche une fois: pourquoi voulez-vous effectuer la recherche une fois pour vérifier la présence (recherche à l'entrée, mais ignore la valeur), et ensuite chercher l'entrée de nouveau pour obtenir la valeur?
    compris. Toutes mes excuses. Merci de prendre le temps!

    OriginalL'auteur JohnD

  2. 2

    En supposant que le code est juste, vous avez un champ d'application-problème. Vous êtes à la déclaration de vos pulledObject à l'intérieur de la si-déclaration de la portée, ce qui le rend inaccessible à l'extérieur pour votre retour-déclaration de travail.

    public Object GetObject(string foo)
{
    object pulledObject = null;
    if(someDict.ContainsKey(foo))
    {
        pulledObject = someDict[foo];
    }
    return pulledObject;
}

    ou (avec l'aimable autorisation de Jon Skeet)

    public Object GetObject(string foo)
{
    object pulledObject = null;
    someDict.TryGetValue(foo, out pulledObject);
    return pulledObject;
}
    Le if énoncé dans la deuxième est redondant. Si TryGetValue renvoie la valeur false, pulledObject va déjà être null.
    Je VIENS de lire ça, la réalisation de mon licenciement-faute. =)

    OriginalL'auteur J. Steen

  3. 1

    La raison que votre code ne fonctionne pas n'est pas que pulledObject a un mauvais type, mais parce qu'il est hors de portée. Vous pouvez faire ceci:

    public Object GetObject(string foo){
    if(someDict.ContainsKey(foo)) {
        return someDict[foo];
    }
    return null;
}

    Les utilisateurs voudrais appeler votre GetObject comme suit:

    object res = GetObject(foo);
if (res == null) {
    //Object is not there - do something else
}

    L'inconvénient de ce modèle est l'incapacité à distinguer les situations lorsque l'objet est là, mais il est null de situations lorsque l'objet n'est pas là. Une approche plus "natif".NET dictionnaire de l'API serait d'utiliser TryGetValue au lieu de GetObject, comme ceci:

    object res;
if (someDict.TryGetValue(foo, out res)) {
} else {
    //Object is not there - do something else
}

    Cette approche effectue l'opération de recherche qu'une seule fois, en enregistrant le CPU (même si en insistant sur l'utilisation de cette approche pour la prétendue amélioration de la vitesse serait une micro-optimisation).

    OriginalL'auteur dasblinkenlight