Comment analyser JSON avec C #?

J'ai le code suivant:

var user = (Dictionary<string, object>)serializer.DeserializeObject(responsecontent);

L'entrée dans responsecontentest JSON, mais elle n'est pas correctement analysée dans un objet. Comment dois-je le désérialiser correctement?

Je suppose que vous n'utilisez pas Json.NET (package Newtonsoft.Json NuGet). Si tel est le cas, vous devriez l'essayer.

Il présente les caractéristiques suivantes:

1. LINQ à JSON
2. Le JsonSerializer pour convertir rapidement vos objets .NET en JSON et vice-versa
3. Json.NET peut éventuellement produire un JSON bien formaté et en retrait pour le débogage ou l'affichage
4. Des attributs tels que JsonIgnore et JsonProperty peuvent être ajoutés à une classe pour personnaliser la façon dont une classe est sérialisée
5. Possibilité de convertir JSON vers et depuis XML
6. Prend en charge plusieurs plates-formes: .NET, Silverlight et le Compact Framework

Regardez l' exemple ci-dessous. Dans cet exemple, la JsonConvertclasse est utilisée pour convertir un objet vers et depuis JSON. Il a deux méthodes statiques à cet effet. Ils sont SerializeObject(Object obj)et DeserializeObject<T>(String json):

Product product = new Product();
product.Name = "Apple";
product.Expiry = new DateTime(2008, 12, 28);
product.Price = 3.99M;
product.Sizes = new string[] { "Small", "Medium", "Large" };

string json = JsonConvert.SerializeObject(product);
//{
//  "Name": "Apple",
//  "Expiry": "2008-12-28T00:00:00",
//  "Price": 3.99,
//  "Sizes": [
//    "Small",
//    "Medium",
//    "Large"
//  ]
//}

Product deserializedProduct = JsonConvert.DeserializeObject<Product>(json);

Comme il a été répondu ici - Désérialiser JSON en objet dynamique C #?

C'est assez simple en utilisant Json.NET:

dynamic stuff = JsonConvert.DeserializeObject("{ 'Name': 'Jon Smith', 'Address': { 'City': 'New York', 'State': 'NY' }, 'Age': 42 }");

string name = stuff.Name;
string address = stuff.Address.City;

Ou en utilisant Newtonsoft.Json.Linq:

dynamic stuff = JObject.Parse("{ 'Name': 'Jon Smith', 'Address': { 'City': 'New York', 'State': 'NY' }, 'Age': 42 }");

string name = stuff.Name;
string address = stuff.Address.City;

Voici quelques options sans utiliser de bibliothèques tierces:

// For that you will need to add reference to System.Runtime.Serialization
var jsonReader = JsonReaderWriterFactory.CreateJsonReader(Encoding.UTF8.GetBytes(@"{ ""Name"": ""Jon Smith"", ""Address"": { ""City"": ""New York"", ""State"": ""NY"" }, ""Age"": 42 }"), new System.Xml.XmlDictionaryReaderQuotas());

// For that you will need to add reference to System.Xml and System.Xml.Linq
var root = XElement.Load(jsonReader);
Console.WriteLine(root.XPathSelectElement("//Name").Value);
Console.WriteLine(root.XPathSelectElement("//Address/State").Value);

// For that you will need to add reference to System.Web.Helpers
dynamic json = System.Web.Helpers.Json.Decode(@"{ ""Name"": ""Jon Smith"", ""Address"": { ""City"": ""New York"", ""State"": ""NY"" }, ""Age"": 42 }");
Console.WriteLine(json.Name);
Console.WriteLine(json.Address.State);

Voir le lien pour plus d'informations sur System.Web.Helpers.Json .

Mise à jour : De nos jours, le moyen le plus simple d'obtenir le Web.Helpersest d'utiliser le package NuGet .

Si vous ne vous souciez pas des versions antérieures de Windows, vous pouvez utiliser les classes de l' Windows.Data.Jsonespace de noms:

// minimum supported version: Win 8
JsonObject root = Windows.Data.Json.JsonValue.Parse(jsonString).GetObject();
Console.WriteLine(root["Name"].GetString());
Console.WriteLine(root["Address"].GetObject()["State"].GetString());

Si .NET 4 est à votre disposition, consultez: http://visitmix.com/writings/the-rise-of-json (archive.org)

Voici un extrait de ce site:

WebClient webClient = new WebClient();
dynamic result = JsonValue.Parse(webClient.DownloadString("https://api.foursquare.com/v2/users/self?oauth_token=XXXXXXX"));
Console.WriteLine(result.response.user.firstName);

Cette dernière Console.WriteLine est assez douce ...

Une autre solution native à cela, qui ne nécessite aucune bibliothèque tierce mais une référence à System.Web.Extensions est JavaScriptSerializer. Ce n'est pas une nouveauté mais une fonctionnalité intégrée très inconnue depuis la 3.5.

using System.Web.Script.Serialization;

..

JavaScriptSerializer serializer = new JavaScriptSerializer();
objectString = serializer.Serialize(new MyObject());

et retour

MyObject o = serializer.Deserialize<MyObject>(objectString)

Vous pouvez également consulter le DataContractJsonSerializer

System.Json fonctionne maintenant ...

Installez nuget https://www.nuget.org/packages/System.Json

PM> Install-Package System.Json -Version 4.5.0

Échantillon :

// PM>Install-Package System.Json -Version 4.5.0

using System;
using System.Json;

namespace NetCoreTestConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            // Note that JSON keys are case sensitive, a is not same as A.

            // JSON Sample
            string jsonString = "{\"a\": 1,\"b\": \"string value\",\"c\":[{\"Value\": 1}, {\"Value\": 2,\"SubObject\":[{\"SubValue\":3}]}]}";

            // You can use the following line in a beautifier/JSON formatted for better view
            // {"a": 1,"b": "string value","c":[{"Value": 1}, {"Value": 2,"SubObject":[{"SubValue":3}]}]}

            /* Formatted jsonString for viewing purposes:
            {
               "a":1,
               "b":"string value",
               "c":[
                  {
                     "Value":1
                  },
                  {
                     "Value":2,
                     "SubObject":[
                        {
                           "SubValue":3
                        }
                     ]
                  }
               ]
            }
            */

            // Verify your JSON if you get any errors here
            JsonValue json = JsonValue.Parse(jsonString);

            // int test
            if (json.ContainsKey("a"))
            {
                int a = json["a"]; // type already set to int
                Console.WriteLine("json[\"a\"]" + " = " + a);
            }

            // string test
            if (json.ContainsKey("b"))
            {
                string b = json["b"];  // type already set to string
                Console.WriteLine("json[\"b\"]" + " = " + b);
            }

            // object array test
            if (json.ContainsKey("c") && json["c"].JsonType == JsonType.Array)
            {
                // foreach loop test
                foreach (JsonValue j in json["c"])
                {
                    Console.WriteLine("j[\"Value\"]" + " = " + j["Value"].ToString());
                }

                // multi level key test
                Console.WriteLine("json[\"c\"][0][\"Value\"]" + " = " + json["c"][0]["Value"].ToString());
                Console.WriteLine("json[\"c\"][0][\"Value\"]" + " = " + json["c"][1]["Value"].ToString());
                Console.WriteLine("json[\"c\"][1][\"SubObject\"][0][\"SubValue\"]" + " = " + json["c"][1]["SubObject"][0]["SubValue"].ToString());
            }

            Console.WriteLine();
            Console.Write("Press any key to exit.");
            Console.ReadKey();
        }
    }
}

Utilisez cet outil pour générer une classe basée sur votre json:

http://json2csharp.com/

Et puis utilisez la classe pour désérialiser votre json. Exemple:

public class Account
{
    public string Email { get; set; }
    public bool Active { get; set; }
    public DateTime CreatedDate { get; set; }
    public IList<string> Roles { get; set; }
}


string json = @"{
  'Email': 'james@example.com',
  'Active': true,
  'CreatedDate': '2013-01-20T00:00:00Z',
  'Roles': [
    'User',
    'Admin'
  ]
}";

Account account = JsonConvert.DeserializeObject<Account>(json);

Console.WriteLine(account.Email);
// james@example.com

Références: https://forums.asp.net/t/1992996.aspx?Nested+Json+Deserialization+to+C+object+and+using+that+object https://www.newtonsoft.com/json/help /html/DeserializeObject.htm

Essayez le code suivant:

HttpWebRequest request = (HttpWebRequest)WebRequest.Create("URL");
JArray array = new JArray();
using (var twitpicResponse = (HttpWebResponse)request.GetResponse())
using (var reader = new StreamReader(twitpicResponse.GetResponseStream()))
{
    JavaScriptSerializer js = new JavaScriptSerializer();
    var objText = reader.ReadToEnd();

    JObject joResponse = JObject.Parse(objText);
    JObject result = (JObject)joResponse["result"];
    array = (JArray)result["Detail"];
    string statu = array[0]["dlrStat"].ToString();
}

System.Text.Json

.NET core 3.0 est livré avec System.Text.Jsonce qui signifie que vous pouvez désérialiser / sérialiser JSON sans utiliser de bibliothèque tierce.

Pour sérialiser vos classes en chaîne JSON:

var json = JsonSerializer.Serialize(order);

Pour désérialiser le JSON en une classe fortement typée:

var order = JsonSerializer.Deserialize<Order>(json);

Donc, si vous avez une classe comme ci-dessous:

public class Order
{
    public int Id { get; set; }
    public string OrderNumber { get; set; }
    public decimal Balance { get; set; }
    public DateTime Opened { get; set; }
}

var json = JsonSerializer.Serialize(order);
// creates JSON ==>
{
    "id": 123456,
    "orderNumber": "ABC-123-456",
    "balance": 9876.54,
    "opened": "2019-10-21T23:47:16.85",
};

var order = JsonSerializer.Deserialize<Order>(json);
// ==> creates the above class

Une chose à noter est que System.Text.Json ne gère pas automatiquement camelCaseles propriétés JSON lors de l'utilisation de votre propre code (cependant, il le fait lors de l'utilisation des requêtes MVC / WebAPI et du classeur de modèle).

Pour résoudre ce problème, vous devez passer JsonSerializerOptionsen paramètre.

JsonSerializerOptions options = new JsonSerializerOptions
{        
    PropertyNamingPolicy = JsonNamingPolicy.CamelCase,  // set camelCase       
    WriteIndented = true                                // write pretty json
};

// pass options to serializer
var json = JsonSerializer.Serialize(order, options);
// pass options to deserializer
var order = JsonSerializer.Deserialize<Order>(json, options);

System.Text.Json est également disponible pour .Net Framework et .Net Standard en tant que package Nu-get System.Text.Json

Les éléments suivants du site msdn devraient, je pense, aider à fournir des fonctionnalités natives pour ce que vous recherchez. Veuillez noter qu'il est spécifié pour Windows 8. Un exemple du site est répertorié ci-dessous.

JsonValue jsonValue = JsonValue.Parse("{\"Width\": 800, \"Height\": 600, \"Title\": \"View from 15th Floor\", \"IDs\": [116, 943, 234, 38793]}");
double width = jsonValue.GetObject().GetNamedNumber("Width");
double height = jsonValue.GetObject().GetNamedNumber("Height");
string title = jsonValue.GetObject().GetNamedString("Title");
JsonArray ids = jsonValue.GetObject().GetNamedArray("IDs");

Il utilise l' espace de noms Windows.Data.JSON .

Vous pouvez utiliser les extensions suivantes

public static class JsonExtensions
{
    public static T ToObject<T>(this string jsonText)
    {
        return JsonConvert.DeserializeObject<T>(jsonText);
    }

    public static string ToJson<T>(this T obj)
    {
        return JsonConvert.SerializeObject(obj);
    } 
}

Je pense que la meilleure réponse que j'ai vue a été @MD_Sayem_Ahmed.

Votre question est "Comment puis-je analyser Json avec C #", mais il semble que vous souhaitiez décoder Json. Si vous voulez le décoder, la réponse d'Ahmed est bonne.

Si vous essayez d'accomplir cela dans ASP.NET Web Api, le moyen le plus simple consiste à créer un objet de transfert de données qui contient les données que vous souhaitez affecter:

public class MyDto{
    public string Name{get; set;}
    public string Value{get; set;}
}

Vous avez simplement ajouté l'en-tête application / json à votre demande (si vous utilisez Fiddler, par exemple). Vous utiliseriez ensuite cela dans l'API Web ASP.NET comme suit:

//controller method -- assuming you want to post and return data
public MyDto Post([FromBody] MyDto myDto){
   MyDto someDto = myDto;
   /*ASP.NET automatically converts the data for you into this object 
    if you post a json object as follows:
{
    "Name": "SomeName",
      "Value": "SomeValue"
}
*/
   //do some stuff
}

Cela m'a beaucoup aidé lorsque je travaillais dans mon Web Api et m'a rendu la vie super facile.

         string json = @"{
            'Name': 'Wide Web',
            'Url': 'www.wideweb.com.br'}";

        JavaScriptSerializer jsonSerializer = new JavaScriptSerializer();
        dynamic j = jsonSerializer.Deserialize<dynamic>(json);
        string name = j["Name"].ToString();
        string url = j["Url"].ToString();

var result = controller.ActioName(objParams);
IDictionary<string, object> data = (IDictionary<string, object>)new System.Web.Routing.RouteValueDictionary(result.Data);
Assert.AreEqual("Table already exists.", data["Message"]);

 using (var ms = new MemoryStream(Encoding.Unicode.GetBytes(user)))
 {
    // Deserialization from JSON  
    DataContractJsonSerializer deserializer = new DataContractJsonSerializer(typeof(UserListing))
    DataContractJsonSerializer(typeof(UserListing));
    UserListing response = (UserListing)deserializer.ReadObject(ms);

 }

 public class UserListing
 {
    public List<UserList> users { get; set; }      
 }

 public class UserList
 {
    public string FirstName { get; set; }       
    public string LastName { get; set; } 
 }