DESerialize JSON en objets c # dynamiquement

Créez un constructeur pour chaque type de réponse qui se construit en analysant une chaîne d'objet JSON. Faites en sorte que toutes les réponses implémentent une interface, par ex. Je réponds. Mappez tous les constructeurs (en tant que fonctions) aux ID de question correspondants dans un dictionnaire. Enfin, parcourez les questions, appelez chaque constructeur et placez-les peut-être dans un nouveau dictionnaire. Exemple de code:

    interface IAnswer { };

    public class ExampleAnswer : IAnswer
    {
        public ExampleAnswer(String JSONObject)
        {
            // Parse JSON here
        }
    }

    delegate IAnswer AnswerConstructor(String JSONObject);

    Dictionary<int, AnswerConstructor> Constructors = new Dictionary<int, AnswerConstructor>()
    {
        {1234, ((AnswerConstructor)(json => new ExampleAnswer(json)))}
        // Add all answer types here
    };

    Dictionary<int, IAnswer> ParseAnswers(Dictionary<int, String> JSONObjects)
    {
        var result = new Dictionary<int, IAnswer>();
        foreach (var pair in JSONObjects)
            result.Add(pair.Key, Constructors[pair.Key](pair.Value));

        return result;
    }

Edit: Regardez la réponse de Matt pour quelques bonnes options pour analyser JSON.

Edit2, En réponse à votre modification: Cela ressemble à une bonne façon de le faire! Je pense que c'est mieux que ma réponse, car vous pouvez conserver toutes les informations de type, contrairement à ma méthode.

La seule chose que je vois que vous voudrez peut-être changer est d'utiliser else if ou switch au lieu de plusieurs ifs. Cela pourrait améliorer les performances si vous avez de nombreuses réponses.

Vous avez plusieurs options:

1. Désérialisation en un objet dynamique à l'aide du package System.Web selon cette réponse ou le package JSON.Net selon cette réponse puis utilisez les vérifications conditionnelles / l ' opérateur de propagation nul a> pour accéder à une propriété.

2. Désérialisez automatiquement jusqu'au niveau où il y a des différences, puis disposez d'un code pour désérialiser manuellement les propriétés qui sont différentes dans les types POCO corrects sur votre objet désérialisé parent.

3. Tirez parti de l'un des rappels de sérialisation fournis par JSON.Net (OnDeserializing ou OnDeserialized) pour gérer le remplissage des différentes propriétés dans les types appropriés dans le cadre du pipeline de désérialisation.

Avec les approches 2 et 3, vous pouvez écrire une méthode d'aide plus agréable sur votre POCO qui inspecte les propriétés des objets et renvoie un résultat qui serait le type qui a été défini (je recommanderais de renvoyer un Enum) par exemple:

public PropertyTypeEnum GetPropertyType(MyPocoClass myPocoClass)
{
    if (myPocoClass.PropertyOne != null)
    {
        return PropertyTypeEnum.TypeOne;
    }
    else if (...)
    {
        return PropertyTypeEnum.TypeN
    }
    else
    {
        // probably throw a NotImplementedException here depending on your requirements
    }
}

Ensuite, dans votre code pour utiliser l'objet, vous pouvez utiliser l'Enum retourné pour activer les chemins logiques de votre code.

Personnellement, je n'aime pas toutes les options qui impliquent une analyse personnalisée et une recherche directe sur les questions.

Vous pouvez utiliser la désérialisation partielle via classe JToken .

Déclarez simplement votre dictionnaire réponses comme tel :

public class Address
{
    public string Name { get; set; }

    // all the othe properties
    // ....

    public static Address From(Dictionary<int, JToken> answers)
    {
        return answers?.TryGetValue(37, out var address) ?? false
            ? address?.ToObject<Address>()
            : null;
    }
}

// so you can just write:
var address = Address.From(answers);

Et chaque fois que vous avez besoin de la page d'adresse, vous pouvez simplement faire Answers [37] .ToObject

()

. La façon dont vous parvenez à appeler cette méthode dépend du reste de votre code, mais vous pouvez l'intégrer dans des propriétés, dans un gros commutateur, dans plusieurs méthodes, une pour chaque classe. Une option que j'aime est d'avoir une méthode statique From dans chaque classe désérialisable:

public Dictionary<int, JToken> Answers{ get; set; }

En remarque, rappelez-vous que les paramètres de désérialisation par défaut pour Json.Net est insensible à la casse, vous pouvez donc désérialiser la propriété name de JSON en une propriété Name plus idiomatique sur vos POCO.