Comment désérialiser JSON pour les objets dont le type est correct, sans avoir à définir le type avant de la main?

J'ai cherché à travers des questions similaires et ne pouvais pas trouver quelque chose qui correspondait tout à fait ce que je cherchais.

Nouvelle C# afin de garder avec moi s'il vous plaît.

J'ai quelques fichiers json que je suis de la désérialisation. Je veux que les fichiers de désérialiser des objets du type correct, sans avoir à définir le type avant de la main. Voici mon code:

public class loadJson
    {
        //path of the file location
        public void readJson(string path)
        {
            //array of files at the path location. right now just reading one file
            FileInfo[] files = new DirectoryInfo(path).GetFiles("seleniumExample.json").ToArray();

            foreach (FileInfo fi in files)
            {

                dynamic b1 = null;
                using (StreamReader file = new StreamReader(fi.FullName))
                {

                    string fileText = file.ReadToEnd();
                    //Console.WriteLine(fileText);

                    try
                    {
                        b1 = Newtonsoft.Json.JsonConvert.DeserializeObject(fileText);
                    }
                    catch(Exception e)
                    {
                        Console.WriteLine("ERROR!!!! " + e.ToString());
                    }

                    file.Close();
                }
            }
        }
    }

J'ai un tas de types d'objet que je vais nourrir mon programme par le biais de fichiers json.

Je ne veux pas avoir à appeler explicitement b1 une Offre, ou d'un Client, ou de toute autre classe prédéfinie. Si je ne explicitement appel b1 une Offre, il charge toutes les infos pour l'amende et remplit le bon de variables d'instance.

Mais quand j'utilise "dynamique" ou "objet", il ne peut pas le comprendre et juste initialise à un "objet".

Est-il un moyen pour effectuer générique de la désérialisation et l'avoir créer un objet de la classe correcte basée sur les champs définis dans le fichier json?

Merci d'avance pour l'aide, et je m'excuse si ma question est incroyablement clair. Si oui, s'il vous plaît laissez-moi savoir comment je peux aider à lever toute ambiguïté. Merci encore.

Is there a way to perform generic deserialization and have it create an object of the correct class based on the fields defined in the json file?

Supposons que Json.Net deviné le correct de la classe et retourné l'objet. Comment voulez-vous utiliser dans votre code? Vous ne savez toujours pas le type de b1 lors de l'écriture de votre code.
Donc, ma pensée est ceci: au Lieu d'écrire une de ces readJson() les méthodes de chaque classe que je vais potentiellement alimenter mon programme comme un fichier JSON, j'ai pensé que je pouvais le faire dans un générique de la mode et de ne pas avoir à réutiliser trop de code. N'est-ce pas logique? Encore une fois, je suis nouveau en c# et le développement de logiciels en général, donc je suis ouvert à l'idée que cela pourrait ne pas être la meilleure façon d'aller.
Vous avez la possibilité de contrôler le format & contenu des fichiers JSON? Ou sont-ils un?
J'ai la capacité de contrôler le format et le contenu.
Faire tous les fichiers JSON dans le répertoire de stocker des objets de même type?

OriginalL'auteur kdeez | 2015-04-17

c#deserialization json serialization

13

Json.NET a la capacité d'enregistrer .Net type d'objet polymorphe types lors de la sérialisation, à l'aide du paramètre TypeNameHandling = TypeNameHandling.Auto. Lorsque le paramètre est activé, l' .Net type de polymorphe objets apparaît comme une synthèse de propriété appelée "$type", par exemple:
```
"$type": "Newtonsoft.Json.Samples.Stockholder, Newtonsoft.Json.Tests"
```
Cependant, la "$type" propriété n'est jamais émis pour le racine objet si vous appelez les méthodes conventionnelles JsonConvert.SerializeObject(Objet) ou JsonSerializer.Serialize(TextWriter, Objet). Au lieu de cela, vous devez utiliser l'une des méthodes de sérialisation qui accepte un "attendu" type de racine, par exemple SerializeObject(Objet, le Type, la JsonSerializerSettings) ou JsonSerializer.Serialize(TextWriter, Objet, Type). En passant typeof(object) que le type attendu de garanties de la propriété type apparaît:
```
var settings = new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto };
var json = JsonConvert.SerializeObject(rootObject, typeof(object), settings);
```
Si vous créez vos fichiers JSON à l'aide de ce paramètre, le JSON sera lui-même rappelez-vous que le type de l'objet sérialisé. Ce type est utilisé par Json.NET lors de la désérialisation, aussi longtemps que vous utilisez set TypeNameHandling quelque chose d'autre que TypeNameHandling.None. par exemple:
```
var settings = new Newtonsoft.Json.JsonSerializerSettings { TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto };
b1 = Newtonsoft.Json.JsonConvert.DeserializeObject(fileText, settings);
```
Échantillon de travail .Net violon ici.

Mises en garde: ce mode de stockage .Types de filets dans le JSON est non standard. D'autres sérialiseurs comme DataContractJsonSerializer ne pas traiter les informations de type dans ce format.

Note aussi cette mise en garde de la Newtonsoft docs:

TypeNameHandling doit être utilisé avec prudence lorsque votre application désérialise JSON à partir d'une source externe. Entrant types doit être validée par une coutume SerializationBinder lors de la désérialisation avec une valeur autre que None.

Pour une discussion des raisons pour lesquelles cela peut être nécessaire, voir TypeNameHandling prudence dans Newtonsoft Json, Comment configurer Json.NET pour créer un web vulnérables API, et Alvaro Muñoz & Oleksandr Mirosh du blackhat papier https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf.

Même, si le Json a été sérialisé à l'aide de $type, la non-générique DeserializeObject surcharge (au moins pour la racine de l'objet) ne pas utiliser le convertisseur. Voir ma question ici: stackoverflow.com/questions/50374760/...
si $type est spécifié, DeserializeObject retours de ce type (et pas de e.g JToken), voir l'exemple dans l'autre question, liée ci-dessus
vous avez raison. Je n'ai jamais utiliser la non-générique version donc, j'avais oublié la façon dont cette méthode traite "$type". J'ai ajouté un lien vers une mise à jour de violon pour confirmer le comportement.

OriginalL'auteur dbc

Désérialiser votre JSON dans la forme la plus basique:

Dictionary<string, object> theData= new JavaScriptSerializer().Deserialize<Dictionary<string, object>>(jsonString);

string baseItemName = (string)theData["baseItem"];

Dictionary<string, object> someNode= (Dictionary<string, object>)theData["something"];

string anything = (string)someNode["anything"];
string nothing = (string)someNode["nothing"];

L'appel à Deserialize() crée un arbre de Dictionary<string, object> que vous pouvez parcourir à volonté.

OriginalL'auteur Daniel Randall

Vous devez vous connecter pour publier un commentaire.