如何将 JSON 对象转换为自定义 C# 对象？-解网

问：

有没有一种简单的方法可以使用通过 AJAX 传递的 JSON 对象填充我的 C# 对象？

这是使用 JSON.stringify 从页面传递到 C# Web 方法的 JSON 对象：

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

接收 JSON 对象的 C# Web 方法：

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

}

表示传入 Web 方法的 JSON Object 的对象结构的 C# 类

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

C# asp.net .NET AJAX JSON

82赞 JonathanK 4/18/2011

想补充一点，您可以使用 json2csharp.com 为您生成 c# 类。完全披露：我确实创建了这个网站。

0赞 Pratik Bhoir 6/25/2015

检查这个 stackoverflow.com/questions/22191167/...

0赞 Jamshaid K. 6/14/2022

与此相反，实际上有一个更好的工具来生成类，这是 app.quicktype.io，为您的模型提供了良好的自定义。json2csharp

答：

240赞 AndreyAkinshin 2/12/2010 #1

在 C# 中使用 JSON 的一个好方法是使用 JSON.NET

JSON.NET 的快速入门和 API 文档 - 官方网站可帮助您使用它。

如何使用它的示例：

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

8赞 Djeroen 2/16/2016

这就像冠军一样，但是如果我的 json 中有多个项目并且我想制作一个对象列表怎么办？

0赞 user1011138 6/23/2017

@Djeroen：我认为有两种方法。如果项目未分组，请尝试找到拆分字符串的方法，并在循环中重复该过程。如果它们被分组，则使对象成为对象

54赞 womp 2/12/2010 #2

给定代码示例，无需执行任何其他操作。

如果将该 JSON 字符串传递给 Web 方法，它将自动分析 JSON 字符串，并创建一个填充的 User 对象作为 SaveTeam 方法的参数。

不过，一般来说，您可以使用如下所示的类，或者为了获得更大的灵活性，使用各种 Json 框架中的任何一个（Jayrock JSON 是一个很好的框架）来轻松操作 JSON 。JavascriptSerializer

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

1赞 Dragouf 9/19/2011

我认为您必须使用 ienumerable 类型（因此在此示例中为 List<User>）

0赞 SrinivasNaidu 4/29/2014

如果它包含子视图模型，我们如何反序列化

1赞 Serj Sagan 4/30/2016

对于那些寻找的人来说，您需要引用程序集并添加 a 以获取，但是一旦这样做，这似乎是将字符串反序列化为 c# 具体类的最干净的方法。System.Web.Extensionsusing System.Web.Script.SerializationJavaScriptSerializerjson

0赞 Tawab Wakil 5/12/2023

现在任何偶然发现这个答案的人都应该从 MS 自己的文档中了解这个一般建议： 对于 .NET Framework 4.7.2 及更高版本，System.Text.Json 命名空间中的 API 应用于序列化和反序列化。对于早期版本的 .NET Framework，请使用 Newtonsoft.Json。JavaScriptSerializer

1赞 Sky Sanders 2/12/2010 #3

JSON.Net 是最好的选择，但根据对象的形状以及是否存在循环依赖关系，可以使用 JavaScriptSerializer 或 DataContractSerializer。

97赞 Jammin 2/12/2010 #4

若要使选项保持开放状态，如果使用的是 .NET 3.5 或更高版本，下面是一个封装示例，你可以使用泛型直接从框架中使用。正如其他人所提到的，如果它不仅仅是简单的对象，你真的应该使用 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;
}

您将需要：

using System.Runtime.Serialization;

using System.Runtime.Serialization.Json;

0赞 Jammin 2/18/2013

@ChristianPayne哈！好点子，是的，这些应该被包装起来。事后看来，就用 JSON.NET 吧！

2赞 DanKodi 9/16/2013

如果 DataContractJsonSerializer 类不可见，则必须通过右键单击解决方案中的“引用”来添加对 System.Runtime.Serialization 的引用，选择“.NET”选项卡，然后选择“System.Runtime.Serialization”

1赞 dreamerkumar 11/13/2013

这种情况会中断。如果 JSON 对象用单引号表示属性，则此函数将失败。例如，它无法解析 {'Subject'： 'Emailing： Web User Activity Log11'， 'EmbedAsImage'： true}，但它能够解析 {“Subject”： “Emailing： Web User Activity Log11”， “EmbedAsImage”： true}

0赞 dreamerkumar 11/13/2013

另外，我需要用 DataContract 和 DataMember 属性来装饰我的简单类。没有它，它就无法解析。

0赞 Dunc 12/12/2013

与 Vishal 不同，POCO 类对我来说非常有效...... +1，因为这避免了对 JSON.NET 的依赖。

7赞 Ioannis Suarez 12/15/2011 #5

使用不如提供的通用解决方案严格：JavaScriptSerializer()

public static T Deserialize<T>(string json)

当将 json 传递到与您尝试转换为的对象定义不完全匹配的服务器时，这可能会派上用场。

8赞 Syam Developer 6/14/2012 #6

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

更多信息请转到以下链接 http://ishareidea.blogspot.in/2012/05/json-conversion.html

关于你可以在这里阅读。DataContractJsonSerializer Class

1赞 ΩmegaMan 4/26/2013 #7

codeplex 上的 JSON C# 类生成器生成与 NewtonSoftJS 配合使用的类。

37赞 user677607 10/4/2013 #8

以下 2 个示例使用了

System.Web.Script.Serialization 下的 JavaScriptSerializer 或
System.Web.Helpers 下的 Json.Decode

示例 1：使用 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
        }
    }
}

用法：JSON 对象到自定义 C# 对象

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

示例 2：使用 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
        }
    }
}

用法：JSON 对象到自定义 C# 对象

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

此代码需要添加 System.Web.Helpers 命名空间，该命名空间位于

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

或

%ProgramFiles（x86）%\Microsoft ASP.NET\ASP.NET Web 页{VERSION}\Assemblies\System.Web.Helpers.dll

0赞 Jess 6/5/2014

这是一个很好的答案，但棘手的是，对于类型，你没有得到任何真正的类型检查。例如，如果 JSON 包含 C# 代码中错误地键入了“Name”，则为运行时错误（bleh）。dynamic"Name" : "Ahmed"

0赞 Valamas 10/20/2014

谢谢！请更新答案，说明对于示例 1，您需要引用 System.Web.Extensions.dll

269赞 MSTdev 1/21/2015 #9

这依赖于 Newtonsoft NuGet 包，它比默认序列化程序更快。

如果我们有一个类，那么我们可以使用以下代码：

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

如果没有类，则使用 dynamic：

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

1赞 Biniam Eyakem 7/28/2015 #10

JavaScript 序列化程序：需要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);
    }
}

数据协定序列化程序：requires - 泛型类型 T 应该在数据协定上更可序列化using System.Runtime.Serialization.Json;

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

48赞 Daniel 8/20/2015 #11

另一个非常简单的解决方案是使用库 Newtonsoft.Json：

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

1赞 gumuruh 5/11/2020

但是，如果 User 对象在属性中具有另一个 JSon 数据，这将失败......

0赞 Daniel 5/12/2020

@gumuruh我想我不明白你的说法。如果你有一个复杂的对象 witch 属性是另一个复杂的对象，它们也会被转换，只要你的 Json String 的数据正确无误。

2赞 akardon 6/17/2016 #12

在性能方面，我发现 ServiceStack 的序列化程序比其他序列化程序快一些。它是 ServiceStack.Text 命名空间中的 JsonSerializer 类。

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

ServiceStack 可通过 NuGet 包获得：https://www.nuget.org/packages/ServiceStack/

0赞 Praveen Kumar Rejeti 10/20/2017 #13

与其仅作为对象发送，不如创建一个可访问的公共属性类，并将数据发送到 Webmethod。

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

在 Ajax 调用中使用相同的参数名称来发送数据。

上一个：ASP.NET MVC - 设置自定义 IIdentity 或 IPrincipal

下一个：请求已中止：无法创建 SSL/TLS 安全通道

如何将 JSON 对象转换为自定义 C# 对象？

How can I connvert a JSON object to a custom C# object?

评论

评论

评论

评论

评论

评论