Wie analysiere ich JSON ohne JSON.NET-Bibliothek?

Ich versuche, eine Metro-Anwendung für Windows 8 in Visual Studio 2011 zu erstellen. Während ich dies versuche, habe ich einige Probleme beim Parsen JSONohne JSON.NETBibliothek (die Metro-Anwendungen werden noch nicht unterstützt). .

Wie auch immer, ich möchte Folgendes analysieren:

{
   "name":"Prince Charming",
   "artist":"Metallica",
   "genre":"Rock and Metal",
   "album":"Reload",
   "album_image":"http:\/\/up203.siz.co.il\/up2\/u2zzzw4mjayz.png",
   "link":"http:\/\/f2h.co.il\/7779182246886"
}

Sie können die im System.Json-Namespace enthaltenen Klassen verwenden, die in .NET 4.5 hinzugefügt wurden. Sie müssen einen Verweis auf die Assembly System.Runtime.Serialization hinzufügen

Die JsonValue.Parse () -Methode analysiert JSON-Text und gibt einen JsonValue zurück :

JsonValue value = JsonValue.Parse(@"{ ""name"":""Prince Charming"", ...");

Wenn Sie eine Zeichenfolge mit einem JSON-Objekt übergeben, sollten Sie den Wert in ein JsonObject umwandeln können :

using System.Json;


JsonObject result = value as JsonObject;

Console.WriteLine("Name .... {0}", (string)result["name"]);
Console.WriteLine("Artist .. {0}", (string)result["artist"]);
Console.WriteLine("Genre ... {0}", (string)result["genre"]);
Console.WriteLine("Album ... {0}", (string)result["album"]);

Die Klassen sind denen im System.Xml.Linq-Namespace ziemlich ähnlich .

Ich benutze dies ... habe aber noch nie eine Metro-App-Entwicklung durchgeführt, daher kenne ich keine Einschränkungen für Bibliotheken, die Ihnen zur Verfügung stehen. (Beachten Sie, dass Sie Ihre Klassen wie mit den Attributen DataContract und DataMember markieren müssen.)

public static class JSONSerializer<TType> where TType : class
{
    /// <summary>
    /// Serializes an object to JSON
    /// </summary>
    public static string Serialize(TType instance)
    {
        var serializer = new DataContractJsonSerializer(typeof(TType));
        using (var stream = new MemoryStream())
        {
            serializer.WriteObject(stream, instance);
            return Encoding.Default.GetString(stream.ToArray());
        }
    }

    /// <summary>
    /// DeSerializes an object from JSON
    /// </summary>
    public static TType DeSerialize(string json)
    {
        using (var stream = new MemoryStream(Encoding.Default.GetBytes(json)))
        {
            var serializer = new DataContractJsonSerializer(typeof(TType));
            return serializer.ReadObject(stream) as TType;
        }
    }
}

Also, wenn Sie eine Klasse wie diese hatten ...

[DataContract]
public class MusicInfo
{
    [DataMember]
    public string Name { get; set; }

    [DataMember]
    public string Artist { get; set; }

    [DataMember]
    public string Genre { get; set; }

    [DataMember]
    public string Album { get; set; }

    [DataMember]
    public string AlbumImage { get; set; }

    [DataMember]
    public string Link { get; set; }

}

Dann würden Sie es so verwenden ...

var musicInfo = new MusicInfo
{
     Name = "Prince Charming",
     Artist = "Metallica",
     Genre = "Rock and Metal",
     Album = "Reload",
     AlbumImage = "http://up203.siz.co.il/up2/u2zzzw4mjayz.png",
     Link = "http://f2h.co.il/7779182246886"
};

// This will produce a JSON String
var serialized = JSONSerializer<MusicInfo>.Serialize(musicInfo);

// This will produce a copy of the instance you created earlier
var deserialized = JSONSerializer<MusicInfo>.DeSerialize(serialized);

Für diejenigen, die nicht 4.5 haben, ist hier meine Bibliotheksfunktion, die json liest. Es erfordert einen Projektverweis auf System.Web.Extensions.

using System.Web.Script.Serialization;

public object DeserializeJson<T>(string Json)
{
    JavaScriptSerializer JavaScriptSerializer = new JavaScriptSerializer();
    return JavaScriptSerializer.Deserialize<T>(Json);
}

Normalerweise wird json aufgrund eines Vertrags ausgeschrieben. Dieser Vertrag kann und wird normalerweise in einer Klasse ( T) kodifiziert . Manchmal können Sie ein Wort aus dem json nehmen und den Objektbrowser durchsuchen, um diesen Typ zu finden.

Anwendungsbeispiel:

Angesichts des json

{"logEntries":[],"value":"My Code","text":"My Text","enabled":true,"checkedIndices":[],"checkedItemsTextOverflows":false}

Sie können es in ein RadComboBoxClientStateObjekt wie das folgende analysieren :

string ClientStateJson = Page.Request.Form("ReportGrid1_cboReportType_ClientState");
RadComboBoxClientState RadComboBoxClientState = DeserializeJson<RadComboBoxClientState>(ClientStateJson);
return RadComboBoxClientState.Value;

Haben Sie versucht, zu verwenden JavaScriptSerializer? Es gibt auchDataContractJsonSerializer

Sie können verwenden DataContractJsonSerializer. Siehe diesen Link für weitere Details.

using System;
using System.IO;
using System.Runtime.Serialization.Json;
using System.Text;

namespace OTL
{
    /// <summary>
    /// Before usage: Define your class, sample:
    /// [DataContract]
    ///public class MusicInfo
    ///{
    ///   [DataMember(Name="music_name")]
    ///   public string Name { get; set; }
    ///   [DataMember]
    ///   public string Artist{get; set;}
    ///}
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class OTLJSON<T> where T : class
    {
        /// <summary>
        /// Serializes an object to JSON
        /// Usage: string serialized = OTLJSON&lt;MusicInfo&gt;.Serialize(musicInfo);
        /// </summary>
        /// <param name="instance"></param>
        /// <returns></returns>
        public static string Serialize(T instance)
        {
            var serializer = new DataContractJsonSerializer(typeof(T));
            using (var stream = new MemoryStream())
            {
                serializer.WriteObject(stream, instance);
                return Encoding.Default.GetString(stream.ToArray());
            }
        }

        /// <summary>
        /// DeSerializes an object from JSON
        /// Usage:  MusicInfo deserialized = OTLJSON&lt;MusicInfo&gt;.Deserialize(json);
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        public static T Deserialize(string json)
        {
            if (string.IsNullOrEmpty(json))
                throw new Exception("Json can't empty");
            else
                try
                {
                    using (var stream = new MemoryStream(Encoding.Default.GetBytes(json)))
                    {

                        var serializer = new DataContractJsonSerializer(typeof(T));
                        return serializer.ReadObject(stream) as T;
                    }
                }
                catch (Exception e)
                {
                    throw new Exception("Json can't convert to Object because it isn't correct format.");
                }
        }
    }
}