Wie kann ich JSON mit C # analysieren?

Ich habe folgenden Code:

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

Die Eingabe in responsecontentist JSON, wird jedoch nicht ordnungsgemäß in ein Objekt analysiert. Wie soll ich es richtig deserialisieren?

Ich gehe davon aus, dass Sie Json.NET (Newtonsoft.Json NuGet-Paket) nicht verwenden. Wenn dies der Fall ist, sollten Sie es versuchen.

Es hat die folgenden Funktionen:

1. LINQ zu JSON
2. Der JsonSerializer zum schnellen Konvertieren Ihrer .NET-Objekte in JSON und wieder zurück
3. Json.NET kann optional gut formatiertes, eingerücktes JSON zum Debuggen oder Anzeigen erstellen
4. Attribute wie JsonIgnore und JsonProperty können einer Klasse hinzugefügt werden, um die Serialisierung einer Klasse anzupassen
5. Möglichkeit, JSON in und aus XML zu konvertieren
6. Unterstützt mehrere Plattformen: .NET, Silverlight und das Compact Framework

Schauen Sie sich das folgende Beispiel an . In diesem Beispiel wird die JsonConvertKlasse verwendet, um ein Objekt in und aus JSON zu konvertieren. Zu diesem Zweck gibt es zwei statische Methoden. Sie sind SerializeObject(Object obj)und 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);

Wie hier beantwortet - JSON in dynamisches C # -Objekt deserialisieren?

Mit Json.NET ist das ganz einfach:

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

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

Oder mit 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;

Hier sind einige Optionen ohne Verwendung von Bibliotheken von Drittanbietern:

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

Weitere Informationen zu System.Web.Helpers.Json finden Sie unter dem Link .

Update : Heutzutage ist es am einfachsten, Web.Helpersdas NuGet-Paket zu verwenden .

Wenn Sie sich nicht für frühere Windows-Versionen interessieren, können Sie die Klassen des Windows.Data.JsonNamespace verwenden:

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

Wenn Ihnen .NET 4 zur Verfügung steht, lesen Sie Folgendes: http://visitmix.com/writings/the-rise-of-json (archive.org)

Hier ist ein Ausschnitt von dieser Seite:

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

Diese letzte Console.WriteLine ist ziemlich süß ...

Eine weitere native Lösung hierfür, für die keine Bibliotheken von Drittanbietern erforderlich sind, sondern auf System.Web.Extensions verwiesen wird, ist der JavaScriptSerializer. Dies ist keine neue, aber eine sehr unbekannte integrierte Funktion seit 3.5.

using System.Web.Script.Serialization;

..

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

und zurück

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

Sie können sich auch den DataContractJsonSerializer ansehen

System.Json funktioniert jetzt ...

Installieren Sie nuget https://www.nuget.org/packages/System.Json

PM> Install-Package System.Json -Version 4.5.0

Beispiel :

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

Verwenden Sie dieses Tool, um eine Klasse zu generieren, die auf Ihrem JSON basiert:

http://json2csharp.com/

Und dann verwenden Sie die Klasse, um Ihren JSON zu deserialisieren. Beispiel:

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

Referenzen: 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

Versuchen Sie den folgenden 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();
}

System.Text.Json

.NET Core 3.0 System.Text.Jsonist integriert. Dies bedeutet, dass Sie JSON ohne Verwendung einer Bibliothek eines Drittanbieters deserialisieren / serialisieren können .

So serialisieren Sie Ihre Klasse (n) in eine JSON-Zeichenfolge:

var json = JsonSerializer.Serialize(order);

So deserialisieren Sie den JSON in eine stark typisierte Klasse:

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

Wenn Sie also eine Klasse wie die folgende haben:

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

Beachten Sie, dass JSON-Eigenschaften bei Verwendung Ihres eigenen Codes System.Text.Json nicht automatisch verarbeitet werden (bei Verwendung von MVC / WebAPI-Anforderungen und des Modellbinders).camelCase

Um dies zu beheben, müssen Sie JsonSerializerOptionsals Parameter übergeben.

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 ist auch für .Net Framework und .Net Standard als Nu-get-Paket System.Text.Json verfügbar

Das Folgende von der msdn- Site sollte meiner Meinung nach dazu beitragen, einige native Funktionen für das bereitzustellen, wonach Sie suchen. Bitte beachten Sie, dass es für Windows 8 spezifiziert ist. Ein solches Beispiel von der Site ist unten aufgeführt.

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

Es verwendet den Windows.Data.JSON- Namespace.

Sie können folgende Erweiterungen verwenden

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

Ich denke, die beste Antwort, die ich gesehen habe, war @MD_Sayem_Ahmed.

Ihre Frage lautet "Wie kann ich Json mit C # analysieren?", Aber anscheinend möchten Sie Json entschlüsseln. Wenn Sie es entschlüsseln möchten, ist Ahmeds Antwort gut.

Wenn Sie dies in ASP.NET Web Api versuchen, können Sie am einfachsten ein Datenübertragungsobjekt erstellen, das die Daten enthält, die Sie zuweisen möchten:

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

Sie müssen Ihrer Anfrage einfach den Header application / json hinzufügen (wenn Sie beispielsweise Fiddler verwenden). Sie würden dies dann in der ASP.NET-Web-API wie folgt verwenden:

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

Dies hat mir sehr geholfen, als ich in meiner Web-API gearbeitet habe und mein Leben super einfach gemacht hat.

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