C# 如何转换列表<；T>；转换为特定的Json格式

我希望能够将

列表

转换为特定的类似JSON表的格式。在我的例子中，

T

始终是一个简单的对象（没有嵌套属性）。这里有两个例子来说明我想要什么

示例#1:

列表

到JSON

// C# list of Persons
var list = new List<Person>() {
  new Person() { First = "Jesse", Last = "Gavin", Twitter = "jessegavin" },
  new Person() { First = "John", Last = "Sheehan", Twitter = "johnsheehan" }
};

// I want to transform the list above into a JSON object like so
{
  columns : ["First", "Last", "Twitter"],
  rows: [
    ["Jesse", "Gavin", "jessegavin"],
    ["John", "Sheehan", "johnsheehan"]
  ]
}

// C# list of Locations
var list = new List<Location>() {
  new Location() { City = "Los Angeles", State = "CA", Zip = "90210" },
  new Location() { City = "Saint Paul", State = "MN", Zip = "55101" },
};

// I want to transform the list above into a JSON object like so
{
  columns : ["City", "State", "Zip"],
  rows: [
    ["Los Angeles", "CA", "90210"],
    ["Saint Paul", "MN", "55101"]
  ]
}

/C#人员名单
var list=新列表（）{
新人（）{First=“Jesse”，Last=“Gavin”，Twitter=“jessegavin”}，
新人（）{First=“John”，Last=“Sheehan”，Twitter=“johnsheehan”}
};
//我想将上面的列表转换成一个JSON对象，如下所示
{
列：[“第一”、“最后”、“推特”]，
行：[
[“杰西”、“加文”、“杰西加文”]，
[“约翰”、“希恩”、“约翰希恩”]
]
}

---

示例2:

列表
您不需要标准格式的具体原因是什么

要真正回答这个问题：

因为这是JSON语法之外的东西，所以我想不出在默认框架内实现它的方法

一种解决方案是利用属性来装饰要通过有线传输的属性，使用自定义属性，并使用反射循环遍历属性，将其属性名称输出为列标题，然后循环抛出对象并写入值。足够通用，因此它也可以应用于其他对象

public class Location
{
     [JsonFooAttribute("City")]
     public string city {get;set;}
     [JsonFooAttribute("State")]
     public string state {get;set;}
}

使用反射可以获得类型的属性列表：

        var props = typeof(Person).GetProperties();

给定
Person
p的一个实例，您可以得到属性值的枚举，因此：

        props.Select(prop => prop.GetValue(p, null))

用一个通用方法将它们包装起来，添加您最喜欢的Json序列化，您就有了所需的格式。
假设您使用.Net 4，这应该可以满足您的所有需要。该类实际上允许您转换为XML或JSON。CommunicationType的枚举位于底部。如果传递序列化程序的类已使用DataContract和DataMember属性修饰，则序列化程序工作得最好。我在底部加了一个样品。它还需要匿名类型，只要它都是简单类型

反射也可以工作，但是您必须理解所有JSON的细微差别以输出复杂的数据类型，等等。这使用了.NET4中内置的JSON序列化程序。还有一点需要注意，因为JSON没有定义日期类型。Net将日期设置为时髦的ASP.Net自定义格式。只要使用内置反序列化器进行反序列化，它就可以正常工作。如果你需要的话，我可以查到这方面的文件

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

internal class Converter
{

    public static string Convert<T>(T obj, CommunicationType format, bool indent = false, bool includetype = false)
    {
        if (format == CommunicationType.XML)
        {
            return ToXML<T>(obj, includetype, indent);
        }
        else if (format == CommunicationType.JSON)
        {
            return ToJSON<T>(obj);
        }
        else
        {
            return string.Empty;
        }

    }

    private static string ToXML<T>(T obj, bool includetype, bool indent = false)
    {
        if (includetype)
        {
            XElement xml = XMLConverter.ToXml(obj, null, includetype);

            if(indent) {
                return xml.ToString(); 
            }
            else
            { 
                return xml.ToString(SaveOptions.DisableFormatting);
            }

        }
        else
        {
            System.Xml.Serialization.XmlSerializerNamespaces ns = new System.Xml.Serialization.XmlSerializerNamespaces();
            XmlSerializer xs = new XmlSerializer(typeof(T));
            StringBuilder sbuilder = new StringBuilder();
            var xmlws = new System.Xml.XmlWriterSettings() { OmitXmlDeclaration = true, Indent = indent };

            ns.Add(string.Empty, string.Empty);

            using (var writer = System.Xml.XmlWriter.Create(sbuilder, xmlws))
            {
                xs.Serialize(writer, obj, ns);
            }

            string result = sbuilder.ToString();

            ns = null;
            xs = null;
            sbuilder = null;
            xmlws = null;

            return result;
        }
    }

    private static string ToJSON<T>(T obj)
    {
        DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(T));
        using (MemoryStream ms = new MemoryStream())
        {
            string result = string.Empty;
            System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding();

            ser.WriteObject(ms, obj);
            result = encoding.GetString(ms.ToArray());

            ms.Close();
            encoding = null;
            ser = null;

            return result;
        }
    }

}

[DataContract()]
public enum CommunicationType : int
{
    [XmlEnum("0"), EnumMember(Value = "0")]
    XML = 0,

    [XmlEnum("1"), EnumMember(Value = "1")]
    JSON = 1
}

[DataContract(Namespace = "")]
public partial class AppData
{
    [DataMember(Name = "ID")]
    public string ID { get; set; }

    [DataMember(Name = "Key")]
    public string Key { get; set; }

    [DataMember(Name = "Value")]
    public string Value { get; set; }

    [DataMember(Name = "ObjectType")]
    public string ObjectType { get; set; }
}

使用系统；
使用System.Xml.Serialization；
使用系统文本；
使用System.Runtime.Serialization.Json；
使用System.IO；
使用System.Xml.Linq；
内部类转换器
{
公共静态字符串转换（T obj，通信类型格式，bool indent=false，bool includetype=false）
{
if（格式==CommunicationType.XML）
{
返回ToXML（对象，包括类型，缩进）；
}
else if（格式==CommunicationType.JSON）
{
返回到JSON（obj）；
}
其他的
{
返回字符串。空；
}
}
私有静态字符串ToXML（T obj，bool includetype，bool indent=false）
{
if（includetype）
{
XElement xml=XMLConverter.ToXml（obj，null，includetype）；
如果（缩进）{
返回xml.ToString（）；
}
其他的
{ 
返回xml.ToString（SaveOptions.DisableFormatting）；
}
}
其他的
{
System.Xml.Serialization.xmlsializationerNamespaces ns=new System.Xml.Serialization.xmlsializationerNamespaces（）；
XmlSerializer xs=新的XmlSerializer（typeof（T））；
StringBuilder sbuilder=新StringBuilder（）；
var xmlws=new System.Xml.XmlWriterSettings（）{OmitXmlDeclaration=true，Indent=Indent}；
ns.Add（string.Empty，string.Empty）；
使用（var writer=System.Xml.XmlWriter.Create（sbuilder，xmlws））
{
序列化（writer、obj、ns）；
}
字符串结果=sbuilder.ToString（）；
ns=null；
xs=null；
sbuilder=null；
xmlws=null；
返回结果；
}
}
私有静态字符串ToJSON（T obj）
{
DataContractJsonSerializer ser=新的DataContractJsonSerializer（类型（T））；
使用（MemoryStream ms=new MemoryStream（））
{
字符串结果=string.Empty；
System.Text.UTF8Encoding encoding=新的System.Text.UTF8Encoding（）；
ser.WriteObject（ms，obj）；
结果=encoding.GetString（ms.ToArray（））；
Close女士（）；
编码=空；
ser=null；
返回结果；
}
}
}
[DataContract（）]
公共枚举通信类型：int
{
[XmlEnum（“0”），枚举成员（Value=“0”）]
XML=0，
[XmlEnum（“1”），枚举成员（Value=“1”）]
JSON=1
}
[DataContract（名称空间=”）]
公共部分类AppData
{
[数据成员（Name=“ID”）]
公共字符串ID{get；set；}
[DataMember（Name=“Key”）]
公共字符串密钥{get；set；}
[DataMember（Name=“Value”）]
公共字符串值{get；set；}
[DataMember（Name=“ObjectType”）]
公共字符串对象类型{get；set；}
}
这不符合回答条件。这应该是一个注释。我这样问是因为一般来说，当人们像这样离开公路时，最简单的解决方案是它绑定到的元素或控件，这保证了调整。@Mangesh-我知道系统是如何工作的。快速回顾一下我的账户就会发现我没有足够的“分数”来评论。参与对话的唯一方法是将其作为答案发布。@PIKER_32我之所以尝试使用这种格式，是因为它减少了通过导线传输的数据的大小。我有一个特殊的例子，需要将近10000行数据绑定到基于JavaScript的网格（不是我选择的）