JSON nesnesini Özel C # nesnesine dönüştürme

AJAX geçti JSON nesnesi ile benim C # nesne doldurmak için kolay bir yolu var mı?

Bu JSON.stringify kullanarak sayfadan C # WEBMETHOD'a iletilen JSON Nesnesi

{
    "user": {
        "name": "asdf",
        "teamname": "b",
        "email": "c",
        "players": ["1", "2"]
    }
}

JSON nesnesi alan C # WebMetod

[WebMethod]
public static void SaveTeam(Object user)
{

}

WebMethod'a aktarılan JSON Nesnesinin nesne yapısını temsil eden C # Sınıfı

public class User
{
    public string name { get; set; }
    public string teamname { get; set; }
    public string email { get; set; }
    public Array players { get; set; }
}

C # 'da JSON kullanmanın iyi bir yolu JSON.NET ile

Hızlı başlatır ve API Belgeleri gelen Json.NET - Resmi site yardım onunla çalışmak.

Nasıl kullanılacağına dair bir örnek:

public class User
{
    public User(string json)
    {
        JObject jObject = JObject.Parse(json);
        JToken jUser = jObject["user"];
        name = (string) jUser["name"];
        teamname = (string) jUser["teamname"];
        email = (string) jUser["email"];
        players = jUser["players"].ToArray();
    }

    public string name { get; set; }
    public string teamname { get; set; }
    public string email { get; set; }
    public Array players { get; set; }
}

// Use
private void Run()
{
    string json = @"{""user"":{""name"":""asdf"",""teamname"":""b"",""email"":""c"",""players"":[""1"",""2""]}}";
    User user = new User(json);

    Console.WriteLine("Name : " + user.name);
    Console.WriteLine("Teamname : " + user.teamname);
    Console.WriteLine("Email : " + user.email);
    Console.WriteLine("Players:");

    foreach (var player in user.players)
        Console.WriteLine(player);
 }

Hepimiz bir gömlek kodunu sevdiğimizden

Newtonsoft, java script serileştiricisinden daha hızlıdır. ... bu, popüler ve varsayılan serileştiriciden daha iyi olan Newtonsoft NuGet paketine bağlıdır.

dersimiz varsa aşağıda kullanın.

Mycustomclassname oMycustomclassname = Newtonsoft.Json.JsonConvert.DeserializeObject<Mycustomclassname>(jsonString);

sınıf yoksa dinamik kullan

var oMycustomclassname = Newtonsoft.Json.JsonConvert.DeserializeObject<dynamic>(jsonString);

Seçeneklerinizi açık tutmak için .NET 3.5 veya üstünü kullanıyorsanız, Generics'i kullanarak doğrudan çerçeveden kullanabileceğiniz bir örnek. Diğerlerinin de belirttiği gibi, sadece basit nesneler değilse, gerçekten JSON.net kullanmalısınız.

public static string Serialize<T>(T obj)
{
    DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
    MemoryStream ms = new MemoryStream();
    serializer.WriteObject(ms, obj);
    string retVal = Encoding.UTF8.GetString(ms.ToArray());
    return retVal;
}

public static T Deserialize<T>(string json)
{
    T obj = Activator.CreateInstance<T>();
    MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(json));
    DataContractJsonSerializer serializer = new DataContractJsonSerializer(obj.GetType());
    obj = (T)serializer.ReadObject(ms);
    ms.Close();
    return obj;
}

İhtiyacın olacak:

using System.Runtime.Serialization;

using System.Runtime.Serialization.Json;

Kod örneğiniz göz önüne alındığında, başka bir şey yapmanıza gerek yoktur.

Bu JSON dizesini web yönteminize iletirseniz, otomatik olarak JSON dizesini ayrıştırır ve SaveTeam yönteminizin parametresi olarak doldurulmuş bir Kullanıcı nesnesi oluşturur.

Genel JavascriptSerializerolarak , sınıfı aşağıdaki gibi kullanabilir veya daha fazla esneklik için, kolay JSON manipülasyonu için çeşitli Json çerçevelerinden herhangi birini (Jayrock JSON iyidir) kullanabilirsiniz.

 JavaScriptSerializer jss= new JavaScriptSerializer();
 User user = jss.Deserialize<User>(jsonResponse); 

Başka bir basit çözüm Newtonsoft.Json kütüphanesini kullanmaktır:

User user = JsonConvert.DeserializeObject<User>(jsonString);

Aşağıdaki 2 örnek aşağıdakilerden birini kullanmaktadır:

1. System.Web.Script.Serialization veya altındaki JavaScriptSerializer Veya
2. System.Web.Helpers altında Json.Decode

Örnek 1: System.Web.Script.Serialization kullanma

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Script.Serialization;

namespace Tests
{
    [TestClass]
    public class JsonTests
    {
        [TestMethod]
        public void Test()
        {
            var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
            JavaScriptSerializer serializer = new JavaScriptSerializer();
            dynamic jsonObject = serializer.Deserialize<dynamic>(json);

            dynamic x = jsonObject["user"]; // result is Dictionary<string,object> user with fields name, teamname, email and players with their values
            x = jsonObject["user"]["name"]; // result is asdf
            x = jsonObject["user"]["players"]; // result is object[] players with its values
        }
    }
}

Kullanım: JSON nesnesini Özel C # nesnesine

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Script.Serialization;
using System.Linq;

namespace Tests
{
    [TestClass]
    public class JsonTests
    {
        [TestMethod]
        public void TestJavaScriptSerializer()
        {
            var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
            User user = new User(json);
            Console.WriteLine("Name : " + user.name);
            Console.WriteLine("Teamname : " + user.teamname);
            Console.WriteLine("Email : " + user.email);
            Console.WriteLine("Players:");
            foreach (var player in user.players)
                Console.WriteLine(player);
        }
    }

    public class User {
        public User(string json) {
            JavaScriptSerializer serializer = new JavaScriptSerializer();
            var jsonObject = serializer.Deserialize<dynamic>(json);
            name = (string)jsonObject["user"]["name"];
            teamname = (string)jsonObject["user"]["teamname"];
            email = (string)jsonObject["user"]["email"];
            players = jsonObject["user"]["players"];
        }

        public string name { get; set; }
        public string teamname { get; set; }
        public string email { get; set; }
        public Array players { get; set; }
    }
}

Örnek 2: System.Web.Helpers kullanma

using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Helpers;

namespace Tests
{
    [TestClass]
    public class JsonTests
    {
        [TestMethod]
        public void TestJsonDecode()
        {
            var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
            dynamic jsonObject = Json.Decode(json);

            dynamic x = jsonObject.user; // result is dynamic json object user with fields name, teamname, email and players with their values
            x = jsonObject.user.name; // result is asdf
            x = jsonObject.user.players; // result is dynamic json array players with its values
        }
    }
}

Kullanım: JSON nesnesini Özel C # nesnesine

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Web.Helpers;
using System.Linq;

namespace Tests
{
    [TestClass]
    public class JsonTests
    {
        [TestMethod]
        public void TestJsonDecode()
        {
            var json = "{\"user\":{\"name\":\"asdf\",\"teamname\":\"b\",\"email\":\"c\",\"players\":[\"1\",\"2\"]}}";
            User user = new User(json);
            Console.WriteLine("Name : " + user.name);
            Console.WriteLine("Teamname : " + user.teamname);
            Console.WriteLine("Email : " + user.email);
            Console.WriteLine("Players:");
            foreach (var player in user.players)
                Console.WriteLine(player);
        }
    }

    public class User {
        public User(string json) {
            var jsonObject = Json.Decode(json);
            name = (string)jsonObject.user.name;
            teamname = (string)jsonObject.user.teamname;
            email = (string)jsonObject.user.email;
            players = (DynamicJsonArray) jsonObject.user.players;
        }

        public string name { get; set; }
        public string teamname { get; set; }
        public string email { get; set; }
        public Array players { get; set; }
    }
}

Bu kod, içinde bulunan System.Web.Helpers ad alanının eklenmesini gerektirir,

% ProgramFiles% \ Microsoft ASP.NET \ ASP.NET Web Sayfaları {VERSION} \ Assemblies \ System.Web.Helpers.dll

Veya

% ProgramFiles (x86)% \ Microsoft ASP.NET \ ASP.NET Web Sayfaları {VERSION} \ Assemblies \ System.Web.Helpers.dll

Bu yardımcı olur umarım!

public static class Utilities
{
    public static T Deserialize<T>(string jsonString)
    {
        using (MemoryStream ms = new MemoryStream(Encoding.Unicode.GetBytes(jsonString)))
        {    
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
            return (T)serializer.ReadObject(ms);
        }
    }
}

Daha fazla bilgi http://ishareidea.blogspot.in/2012/05/json-conversion.html bağlantısına gidin

Hakkında buradaDataContractJsonSerializer Class okuyabilirsiniz .

JavaScriptSerializer () kullanmak, sunulan genel çözümden daha az katıdır: public static T Deserialize (string json)

Dönüştürmeye çalıştığınız Nesne tanımıyla tam olarak eşleşmeyen sunucuya json iletilirken bu kullanışlı olabilir.

Performans açısından, ServiceStack'ın serileştiricisini diğerlerinden biraz daha hızlı buldum. ServiceStack.Text ad alanında JsonSerializer sınıfıdır.

https://github.com/ServiceStack/ServiceStack.Text

ServiceStack, NuGet paketi aracılığıyla edinilebilir: https://www.nuget.org/packages/ServiceStack/

JSON.Net en iyi bahistir, ancak nesnelerin şekline ve dairesel bağımlılıklar olup olmadığına bağlı olarak JavaScriptSerializer veya DataContractSerializer kullanabilirsiniz.

CodePlex üzerinde JSON C # sınıfı jeneratör NewtonSoftJS ile iyi iş sınıfları oluşturur.

JavaScript Serializer: gerektirir using System.Web.Script.Serialization;

public class JavaScriptSerializerDeSerializer<T>
{
    private readonly JavaScriptSerializer serializer;

    public JavaScriptSerializerDeSerializer()
    {
        this.serializer = new JavaScriptSerializer();
    }

    public string Serialize(T t)
    {
        return this.serializer.Serialize(t);
    }

    public T Deseralize(string stringObject)
    {
        return this.serializer.Deserialize<T>(stringObject);
    }
}

Veri Sözleşmesi Seri Oluşturucusu: gerektirir using System.Runtime.Serialization.Json; - Genel T türü Veri Sözleşmesi'nde daha fazla serileştirilebilir olmalıdır

public class JsonSerializerDeserializer<T> where T : class
{
    private readonly DataContractJsonSerializer jsonSerializer;

    public JsonSerializerDeserializer()
    {
        this.jsonSerializer = new DataContractJsonSerializer(typeof(T));
    }

    public string Serialize(T t)
    {
        using (var memoryStream = new MemoryStream())
        {
            this.jsonSerializer.WriteObject(memoryStream, t);
            memoryStream.Position = 0;
            using (var sr = new StreamReader(memoryStream))
            {
                return sr.ReadToEnd();
            }
        }
    }

    public T Deserialize(string objectString)
    {
        using (var ms = new MemoryStream(System.Text.ASCIIEncoding.ASCII.GetBytes((objectString))))
        {
            return (T)this.jsonSerializer.ReadObject(ms);
        }
    }
}

Sadece bir nesne olarak göndermek yerine.

Erişilebilir bir ortak özellik sınıfı oluşturun ve verileri Web yöntemine gönderin.

[WebMethod]
public static void SaveTeam(useSomeClassHere user)
{
}

veri göndermek için ajax çağrısında aynı parametre adlarını kullanın.