visual Como converter objeto JSON para objeto personalizado C#?




visual studio c# json (11)

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

Mais informações acesse o seguinte link http://ishareidea.blogspot.in/2012/05/json-conversion.html

Sobre DataContractJsonSerializer Class você pode ler here .

Existe uma maneira fácil de preencher meu objeto c # com o objeto JSON passado via AJAX?

// Este é o objeto JSON passado para o C # WEBMETHOD da página usando JSON.stringify

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

// C # WebMetod que recebe o objeto JSON

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

}

// C # Class que representa a estrutura de objeto do Objeto JSON passada para o WebMethod

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

Desde que todos nós amamos um código liners

O Newtonsoft é mais rápido que o serializador de scripts java. ... este depende do pacote Newtonsoft NuGet, que é popular e melhor que o serializador padrão.

se temos classe, então use abaixo.

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

nenhuma classe, em seguida, usar dinâmico

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

JSON.Net é sua melhor aposta, mas, dependendo da forma dos objetos e se existem dependências circulares, você pode usar JavaScriptSerializer ou DataContractSerializer.


O uso de JavaScriptSerializer () é menos estrito que a solução genérica oferecida: public static T Deserialize (string json)

Isso pode ser útil ao passar o json para o servidor que não corresponde exatamente à definição do objeto para a qual você está tentando converter.


Para manter suas opções abertas, se você estiver usando o .NET 3.5 ou posterior, aqui está um exemplo que você pode usar diretamente do framework usando Generics. Como outros já mencionaram, se não são apenas objetos simples, você deve usar o JSON.net.

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

Você precisará:

using System.Runtime.Serialization;

using System.Runtime.Serialization.Json;

Uma boa maneira de usar o JSON em C # é com o JSON.NET

Iniciações Rápidas e Documentação da API do JSON.NET - Site oficial ajuda você a trabalhar com isso.

Um exemplo de como usá-lo:

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


Outra solução realmente simples é usar a biblioteca Newtonsoft.Json:

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


Em vez de enviar apenas um objeto.

Crie uma classe pública de propriedades que seja acessível e envie os dados para o Webmethod.

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

use os mesmos nomes de parâmetros na chamada ajax para enviar dados.


Os dois exemplos seguintes fazem uso de

  1. JavaScriptSerializer em System.Web.Script.Serialization ou
  2. Json.Decode em System.Web.Helpers

Exemplo 1: usando System.Web.Script.Serialization

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

Uso: Objeto JSON para o objeto C # personalizado

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

Exemplo 2: usando System.Web.Helpers

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

Uso: Objeto JSON para o objeto C # personalizado

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

Esse código requer a adição do namespace System.Web.Helpers encontrado em

% ProgramFiles% \ Microsoft Páginas ASP.NET \ ASP.NET {VERSION} \ Assemblies \ System.Web.Helpers.dll

Ou

% ProgramFiles (x86)% \ Microsoft Páginas ASP.NET \ ASP.NET {VERSION} \ Assemblies \ System.Web.Helpers.dll

Espero que isto ajude!







json