Hoe kan ik JSON ontleden met C#?

Ik heb de volgende code:

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

De invoer in responsecontentis JSON, maar het is niet correct geparseerd in een object. Hoe moet ik het op de juiste manier deserialiseren?

Antwoord 1, autoriteit 100%

Ik neem aan dat je Json.NET(Newtonsoft.Json NuGet-pakket) niet gebruikt. Als dit het geval is, moet u het proberen.

Het heeft de volgende kenmerken:

1. LINQ naar JSON
2. De JsonSerializer voor het snel converteren van uw .NET-objecten naar JSON en weer terug
3. Json.NET kan optioneel goed geformatteerde, ingesprongen JSON produceren voor foutopsporing of weergave
4. Kenmerken zoals JsonIgnoreen JsonPropertykunnen aan een klasse worden toegevoegd om aan te passen hoe een klasse wordt geserialiseerd
5. Mogelijkheid om JSON van en naar XML te converteren
6. Ondersteunt meerdere platforms: .NET, Silverlight en het Compact Framework

Bekijk het voorbeeldhieronder. In dit voorbeeld wordt de klasse JsonConvertgebruikt om een object van en naar JSON te converteren. Het heeft hiervoor twee statische methoden. Dit zijn SerializeObject(Object obj)en 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);

Antwoord 2, autoriteit 80%

Zoals hier is beantwoord – JSON deserialiseren in dynamisch C#-object?

Het is vrij eenvoudig om Json.NET te gebruiken:

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

Of met behulp van 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;

Antwoord 3, autoriteit 37%

Hier zijn enkele opties zonderbibliotheken van derden te gebruiken:

// 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);

Zie de link voor meer informatie over system.web.helpers.json .

Update : Tegenwoordig de gemakkelijkste manier om de Web.Helperste krijgen, is om de Nuget-pakket .

Als u niet om eerdere Windows-versies geeft, kunt u de klassen van de Windows.Data.Jsonnamespace:

// 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());

Antwoord 4, Autoriteit 16%

Als .NET 4 is voor u beschikbaar, bekijk dan: http://visitmix.com/writings/the-rise-of-json (Archive.org)

Hier is een fragment vanaf die 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);

Die laatste Console.WriteLine is best lief…

Antwoord 5, autoriteit 11%

Een andere native oplossing hiervoor, waarvoor geen bibliotheken van derden nodig zijn, maar een verwijzing naar System.Web.Extensionsis de JavaScriptSerializer. Dit is geen nieuwe, maar een zeer onbekende ingebouwde functie daar sinds 3.5.

using System.Web.Script.Serialization;

..

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

en terug

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

Antwoord 6, autoriteit 5%

U kunt ook de bekijken DataContractJsonSerializer

Antwoord 7, autoriteit 5%

System.Text.Json

.NET core3.0 wordt geleverd met System.Text.Jsoningebouwd die betekent dat u JSON kunt deserialiseren/serialiseren zondereen bibliotheek van derden te gebruiken.

Om uw klasse(n) te serialiseren naar JSON-tekenreeks:

var json = JsonSerializer.Serialize(order);

Om de JSON te deserialiseren in een sterk getypeerde klasse:

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

Dus als je een les hebt zoals hieronder:

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

Een ding om op te merken is dat System.Text.Jsonnietautomatisch camelCaseJSON-eigenschappen verwerkt wanneer je je eigen code gebruikt (maar wel bij gebruik van MVC/WebAPI-verzoeken en de modelbinder).

Om dit op te lossen, moet u JsonSerializerOptionsals parameter doorgeven.

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.Jsonis ook beschikbaar voor .Net Framework en .Net Standard als een Nu-get-pakket System.Text.Json

Antwoord 8, autoriteit 4%

System.Json werkt nu…

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

PM> Install-Package System.Json -Version 4.5.0

Voorbeeld:

// 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();
        }
    }
}

Antwoord 9, autoriteit 3%

Gebruik deze tool om een klasse te genereren op basis van uw json:

http://json2csharp.com/

En gebruik dan de klasse om je json te deserialiseren. Voorbeeld:

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': '[email protected]',
  'Active': true,
  'CreatedDate': '2013-01-20T00:00:00Z',
  'Roles': [
    'User',
    'Admin'
  ]
}";
Account account = JsonConvert.DeserializeObject<Account>(json);
Console.WriteLine(account.Email);
// [email protected]

Referenties:
https: / /forums.asp.net/t/1992996.aspx?nested+Json+Deserialization+to+c+Object+and+ing+that+Object
https://www.newtonsoft.com/json/help/html/desializeObject.htm

Antwoord 10, Autoriteit 2%

Probeer de volgende code:

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();
}

Antwoord 11

Als JSON dynamisch is zoals hieronder

{
 "Items": [{
        "Name": "Apple",
        "Price": 12.3
    },
    {
        "Name": "Grape",
        "Price": 3.21
    }
   ],
   "Date": "21/11/2010"
}

Zodra u NewtonSoft.Jsonvan NuGet installeert en in uw project opneemt, kunt u het serialiseren als

string jsonString = "{\"Items\": [{\"Name\": \"Apple\",\"Price\": 12.3},{\"Name\": \"Grape\",\"Price\": 3.21}],\"Date\": \"21/11/2010\"}";
        dynamic DynamicData = JsonConvert.DeserializeObject(jsonString);
        Console.WriteLine(   DynamicData.Date); // "21/11/2010"
        Console.WriteLine(DynamicData.Items.Count); // 2
        Console.WriteLine(DynamicData.Items[0].Name); // "Apple"

Bron: Hoe JSON-gegevens in C# te lezen (voorbeeld met Console-app & ASP.NET MVC)?

Antwoord 12

Het volgende van de msdn-site moet ik denken dat het helpt om wat native functionaliteit te bieden voor wat u zoekt. Let op: het is gespecificeerd voor Windows 8. Een voorbeeld van zo’n site staat hieronder vermeld.

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");

Het maakt gebruik van de Windows.Data .JSONnaamruimte.

Antwoord 13

U kunt de volgende extensies gebruiken

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);
    } 
}

Antwoord 14

Ik denk dat het beste antwoord dat ik heb gezien @MD_SAYEM_AHMED.

Uw vraag is “Hoe kan ik json parseren met C #”, maar het lijkt erop dat u JSON wilt decoderen. Als je het wilt decoderen, is het antwoord van Ahmed goed.

Als u dit probeert te bereiken in ASP.NET Web API, is de eenvoudigste manier om een ​​gegevensoverdrachtsobject te maken dat de gegevens die u wilt toewijzen:

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

U hebt eenvoudig de applicatie / JSON-header aan uw verzoek toegevoegd (als u bijvoorbeeld Fiddler gebruikt).
Gebruik dit dan in ASP.NET Web API als volgt:

//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
}

Dit hielp me veel toen ik in mijn web-api werkte en mijn leven super eenvoudig maakte.

Antwoord 15

        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();

Antwoord 16

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"]);

Antwoord 17

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; } 
 }