À l'aide d'un Dictionnaire<string, object> Dictionnaire<string, Dictionnaire<string, string>>

en C# j'ai besoin de conserver les données dans un objet dictionary, ressemble:

Dictionary<string, Dictionary<string, string>> MyDict = 
    new Dictionary<string, Dictionary<string, string>>();

Maintenant j'ai compris, que j'aurais besoin, dans certains cas, certains autres (pas de type dictionnaire de données) de la valeur des principaux dict.

Est-il un genre de Problème ou de limitation, si je viens d'exemple, le principal dict. comme:

Dictionary<string, object> MyDict = new Dictionary<string, object>();

dans le champ d'objet que je pourrais mettre de la chaîne, dictionnaire, que ce soit..

Merci d'avance,
Cordialement, Steven

le titre ne correspond pas au texte de votre question
Je ne pense pas que ce serait un problème. Vous seriez probablement juste besoin de le jeter comme ce qu'il est censé être pour y accéder.
Vous avez pu voir la réponse à cette stackoverflow.com/questions/569903/multi-value-dictionary est-ce que vous souhaitez?
C'est tellement bizarre exigence. Ma première suggestion serait de repenser la conception, pas vraiment. Il n'y a pas beaucoup d'infos disponibles dans la question de suggérer une. Sinon, je suppose que vous pourriez maintenir deux dictionnaires. Si pas de voir Oliver orientée objet de la solution. De loin le meilleur ici.

OriginalL'auteur N471v3 | 2012-02-08

  1. 1

    Par l'utilisation de l'objet comme valeur dans votre dictionnaire, vous devrez vous acquitter de certains risques et complications:

    • Manque de sécurité de type (tout peut être réglé à la valeur)
    • Vous aurait cast vers un type particulier, probablement basée sur la valeur

    Vous devriez revoir votre conception. Mais si vous voulez vraiment un la flexibilité que vous pourriez créer un nouveau type de travail, comme le type de la valeur. Quelque chose comme:

    class MySpecialType
{
    public Dictionary<string, string> MyStringDictionary { get; set; }
    public string MyStringVal {get; set;}

    public Type ActiveType { get; set; } //property would specify the current type
    //...

    Votre dictionnaire principal de déclaration serait quelque chose comme:

    Dictionary<string, MySpecialType> MyDict = new Dictionary<string, MySpecialType>();

    Vous pouvez utiliser le ActiveType de la propriété ou de créer un enum qui permettrait de spécifier le type. Vous pourriez aussi avoir statique util fonctions dans la classe qui pourrait aider avec le retour de la droite de l'instance et le type...

    Votre answear en combinaison avec la connaissance des autres fait le plus de sens pour moi. (merci pour ça!) "Le manque de sécurité de type (tout peut être réglé à la valeur)" serait une fonctionnalité pour moi dans ce cas 😀 Votre solution avec la classe a du sens, mais c'est un peu comme la surcharge j'ai essayé de l'éviter pour moi. Donc résolu, merci à tous, mon Problème principal est le contexte et la conception du code. MERCI

    OriginalL'auteur Paul Sasik

  2. 5

    Oui, votre dictionnaire ne serait pas fortement typé plus - dans la première approche que l'on pourrait faire quelque chose comme:

    string value = myDict["foo"]["bar"];

    Dans la seconde approche, ce n'est plus possible depuis que vous avez lancé en premier:

    string value = ((Dictionary<string,string>)myDict["foo"])["bar"];

    Il semble que votre problème pourrait être résolu avec une meilleure approche de la conception. Généralement, la nécessité de stocker différents types d'objets dans la même structure de données peut être évité par la re-conception de la solution - si pourquoi avez-vous besoin de faire cela?

    Edit:

    Si vous voulez juste pour gérer null valeurs, vous pourriez faire quelque chose comme:

    string value = myDict["foo"] != null ? myDict["foo"]["bar"] : null;

    Ou enveloppé dans une méthode d'extension:

    public static T GetValue<T>(this Dictionary<T, Dictionary<T,T>> dict, 
                            T key, T subKey) where T: class
{
    T value = dict[key] != null ? dict[key][subKey] : null;
    return value;
}

string value = myDict.GetValue("foo", "bar");
    Parce que c'est mis en œuvre tous les plus de 1000 lignes de code, et pour certains cas, il est nécessaire d'ajouter des valeurs à null, où la clé a été utilisé comme données. comme: MyDict.Add("One_key", AnotherDictionary); MyDict.Add("Cool_key", null); que dans la boucle for: si(MyDict.la valeur != null) //faire quelque chose Et votre point de vue est bon, le design est peut-être un peu défectueux! Mais j'ai besoin de la clé et la valeur du champ pour les données maintenant, et je pensais que je ne veux pas en faire un sous-dictionnaire pour ces valeur de la clé de paire à partir d'une inscription avec la valeur null, en raison de code frais généraux, si vous savez ce que je veux dire. (nombre d'entrées null-valeur)
    Merci à vous tous pour la rapidité et la bonne answears!

    OriginalL'auteur BrokenGlass

  3. 4

    Vous pouvez le faire. Après la récupération de données à partir du dictionnaire principal, vous aurez à jeter le résultat d'un type approprié:

    object obj;
If(mainDict.TryGetValue("key", out obj)) {
    var dict = obj as Dictionary<string, string>>;
    if (dict != null) {
        //work with dict
    } else {
        var value = obj as MyOtherType;
        ....
    }
}

    Mais notez que ce n'est pas de type coffre-fort; c'est à dire, le compilateur ne peut que partiellement vérifier la validité de votre code en ce qui concerne les valeurs de type object.

    Sinon, vous pouvez essayer un plus orienté objet solution

    public abstract class MyBaseClass 
{
    public abstract void DoSomething();
}

public class MyDictClass : MyBaseClass
{
    public readonly Dictionary<string, string> Dict = new Dictionary<string, string>();

    public override void DoSomething()
    {
        //So something with Dict
    }
}

public class MyTextClass : MyBaseClass
{
    public string Text { get; set; }

    public override void DoSomething()
    {
        //So something with Text
    }
}

    Ensuite déclarer votre dictionnaire principal avec

    var mainDict = new Dictionary<string, MyBaseClass>();

mainDict.Add("x", new MyDictClass());
mainDict.Add("y", new MyTextClass());

...

MyBaseClass result = mainDict[key];
result.DoSomething(); //Works for dict and text!

    OriginalL'auteur Olivier Jacot-Descombes

  4. 1

    Vous perdrez forte de types et de tous leurs avantages.

    Pouvez-vous ne pas créer une nouvelle classe qui a un Dictionnaire de la propriété et ajouter vos autres données:

    public class CallItWhatYouLike
{
  public Dictionary<string, string> Dictionary {get; set;}
  public int AnotherProperty {get; set;}
  ...
}

var MyDict = new Dictionary<string, CallItWhatYouLike>();

    OriginalL'auteur vc 74

  5. 0

    Non, il n'y a pas de problème. Si vous avez besoin de tapez la valeur que Dictionary<string, string> simplement le jeter et vous aurez cette résolus.

    OriginalL'auteur Matías Fidemraizer

  6. 0

    Bien, votre code sera moins typesafe et vous aurez besoin du runtime vérifications de type et de type de moulages, mais sinon, vous pouvez utiliser object comme un dictionnaire de type de la valeur et de stocker tous les types là.

    OriginalL'auteur wRAR

  7. 0

    Vous devrez payer une pénalité de performances lorsque vous unbox la System.Object, mais à part ça, il n'y a pas un problème avec votre approche autre que excessive de casting pour les indexeurs (en raison de la faiblesse de frappe).

    Vous pouvez envisager d'utiliser un Système.Tuple si vous êtes en utilisant .NET 4.

    OriginalL'auteur SliverNinja - MSFT