C# 是否将对象序列化为由帮助器类创建的ASp.NETMVC命名格式？

我需要序列化一个对象，使其结构和命名约定与MVC引擎为强类型视图生成的相同。我所追求的命名约定是在使用HTML帮助程序时创建的

因此，对于输入：

对象中的属性将是：

public class Address{
     public string Street1 {get; set;}
}

下面是一个示例对象：

public class Listing
    {
        public int Id { get; set; }
        public Address Address { get; set; }
    }


    public  class Address
    {
        public int Id { get; set; }
        public string Street1 { get; set; }
        public Contact Contact { get; set; }
    }

    public class Contact
    {
        public int Id { get; set; }
        public string FirstName { get; set; }
    }

我想序列化对象（假设列表是根对象），使其格式如下，并传递回客户端：

{
"Id":1,
"Address_Id":2,
"Address_Street1":"123 Lane",
"Address_Contact_Id":4
"Address_Contact_FirstName","Bill"
}

MVC助手似乎正在以某种方式实现这一点，我想知道是否有任何内置类在序列化时处理这种类型。我已经试过了，但是代码没有编译，也不确定他们使用的是什么版本的Serializer。这正是我要找的

更新

我觉得自己很愚蠢，但似乎引用链接中的答案可能包含假定为其他解析类的代码

更新2

我想出了这个，看起来效果不错。在某些情况下，我试图解释可为null的类型。我想这取决于我是否需要返回该属性，即使它没有值。目前，我检查一个值是否为null，如果为null，则向

AppendToPathString

方法传递一个空字符串

class Program
    {
        private static void Main(string[] args)
        {
            var listing = new Listing()
                {
                    Id = 1,
                    Address = new Address()
                        {
                            Id = 1,
                            Street1 = "sdfsdfsdfsdfsd",
                            Contact = new Contact()
                                {
                                    FirstName = "ert34253453",
                                    Id = 5,
                                    Created = DateTime.Now
                                }
                        }
                };


            var json = JsonConvert.SerializeObject(listing);

            var jss = new JavaScriptSerializer();
            var o = jss.Deserialize<Dictionary<string, object>>(json);

            var additionalParameters = new Dictionary<string, string>();
            BuildVariablesList(o, "", additionalParameters);
        }



        private static string AppendToPathString(string path, object part)
        {
            return path.Trim().Length == 0 ? part.ToString() : path + '.' + part;
        }

        public static void BuildVariablesList(object obj, string path, Dictionary<string, string> result)
        {
            if (obj is ArrayList)
            {
                var arrayObj = obj as ArrayList;
                for (var i = 0; i < arrayObj.Count; i++)
                {
                    BuildVariablesList(arrayObj[i], AppendToPathString(path, i), result);
                }
            }
            else if (obj is Dictionary<string, object>)
            {
                var dictObject = obj as Dictionary<string, object>;
                foreach (var entry in dictObject)
                {

                    if (entry.Value is Dictionary<string, object>)
                    {
                        BuildVariablesList(entry.Value as Dictionary<string, object>, AppendToPathString(path, entry.Key), result);
                    }
                    else if (entry.Value is ArrayList)
                    {
                        BuildVariablesList(entry.Value as ArrayList, AppendToPathString(path, entry.Key), result);
                    }
                    else
                    {
                       if (entry.Value != null)
                       {
                           result.Add(AppendToPathString(path, entry.Key), entry.Value.ToString());
                       }
                       else
                       {
                           result.Add(AppendToPathString(path, entry.Key), string.Empty);
                       }


                    }
                }
            }

        }
    }

    public class Listing
    {
        public int Id { get; set; }
        public Address Address { get; set; }
    }


    public  class Address
    {
        public int Id { get; set; }
        public string Street1 { get; set; }
        public Contact Contact { get; set; }
    }

    public class Contact
    {
        public int Id { get; set; }
        public string FirstName { get; set; }
        public DateTime Created { get; set; }
        public int? SomeId { get; set; }

    }

类程序
{
私有静态void Main（字符串[]args）
{
var listing=新列表（）
{
Id=1，
地址=新地址（）
{
Id=1，
Street1=“sdfsdfsd”，
联系人=新联系人（）
{
FirstName=“ERT342553”，
Id=5，
Created=DateTime.Now
}
}
};
var json=JsonConvert.SerializeObject（列表）；
var jss=新的JavaScriptSerializer（）；
var o=jss.Deserialize（json）；
var additionalParameters=新字典（）；
buildVariableList（o，“，附加参数）；
}
私有静态字符串AppendToPathString（字符串路径，对象部分）
{
返回path.Trim（）.Length==0？part.ToString（）：path+'.''part；
}
公共静态void BuildVariablesList（对象对象对象、字符串路径、字典结果）
{
if（obj是ArrayList）
{
var arrayObj=obj作为ArrayList；
对于（变量i=0；i

所以这对我来说非常有效。我在

AppendToPathString

方法中添加了一个

delimiter

参数：

private static void Main(string[] args)
        {
            var listing = new Listing()
                {
                    Id = 1,
                    Address = new Address()
                        {
                            Id = 1,
                            Street1 = "sdfsdfsdfsdfsd",
                            Contact = new Contact()
                                {
                                    FirstName = "ert34253453",
                                    Id = 5,
                                    Created = DateTime.Now
                                }
                        }
                };


            var json = JsonConvert.SerializeObject(listing);

            var jss = new JavaScriptSerializer();
            var o = jss.Deserialize<Dictionary<string, object>>(json);

            var additionalParameters = new Dictionary<string, string>();
            BuildVariablesList(o, "", additionalParameters);
        }



        private static string AppendToPathString(string path, object part, string delimiter = ".")
        {
            return path.Trim().Length == 0 ? part.ToString() : path + delimiter  + part;
        }

        public static void BuildVariablesList(object obj, string path, Dictionary<string, string> result)
        {
            if (obj is ArrayList)
            {
                var arrayObj = obj as ArrayList;
                for (var i = 0; i < arrayObj.Count; i++)
                {
                    BuildVariablesList(arrayObj[i], AppendToPathString(path, i), result);
                }
            }
            else if (obj is Dictionary<string, object>)
            {
                var dictObject = obj as Dictionary<string, object>;
                foreach (var entry in dictObject)
                {

                    if (entry.Value is Dictionary<string, object>)
                    {
                        BuildVariablesList(entry.Value as Dictionary<string, object>, AppendToPathString(path, entry.Key), result);
                    }
                    else if (entry.Value is ArrayList)
                    {
                        BuildVariablesList(entry.Value as ArrayList, AppendToPathString(path, entry.Key), result);
                    }
                    else
                    {
                       if (entry.Value != null)
                       {
                           result.Add(AppendToPathString(path, entry.Key), entry.Value.ToString());
                       }
                       else
                       {
                           result.Add(AppendToPathString(path, entry.Key), string.Empty);
                       }


                    }
                }
            }

        }

private static void Main（字符串[]args）
{
var listing=新列表（）
{
Id=1，
地址=新地址（）
{
Id=1，
Street1=“sdfsdfsd”，
联系人=新联系人（）
{
FirstName=“ERT342553”，
Id=5，
Created=DateTime.Now
}
}
};
var json=JsonConvert.SerializeObject（列表）；
var jss=新的JavaScriptSerializer（）；
var o=jss.Deserialize（json）；
var additionalParameters=新字典（）；
buildVariableList（o，“，附加参数）；
}
私有静态字符串AppendToPathString（字符串路径，对象部分，字符串分隔符=“.”）
{
返回path.Trim（）.Length==0？part.ToString（）：路径+分隔符+部分；
}
公共静态void BuildVariablesList（对象对象对象、字符串路径、字典结果）
{
if（obj是ArrayList）
{
var arrayObj=obj作为ArrayList；
对于（变量i=0；i