掷鸡蛋者
发表于: 2013/3/21 7:09 引用 回复 只看该作者 1# TOP
管理员
性别: 男
积分:52169
阅读权限:43381
帖子: 8316
加入时间: 2010/4/29
最后登录: 2019/3/3

json是javascript中的一种数据格式,比如这段javascript代码:
    var user = {Id:8, Name:'zhangsan', Gender:1};
蓝色部分是json格式,可以用来表示“Id是8,姓名是zhangsan,性别是男”的用户。json数据格式是非常精简的,没有什么多余的字符。

字符少的好处,不仅仅是更加清晰易读,而且在浏览器和服务器之间传递数据,数据量要少很多,和xml等格式相比,更加实用。

现在,json基本上成了web开发领域数据交换的事实上的标准。

因为这个原因,wojilu框架在若干年前,在设计框架的时候,就把主要的数据存储格式、交换格式等等,用json来表示,没有使用繁重的xml(虽然.net是直接支持xml的,你要在wojilu中使用xml绝对可以)。比如缓存数据在持久化的时候,就是用的json。

同时,wojilu frameowork还专门为json设计了一套解析器,内置在框架中,不必使用第三方dll,就可以直接解释json数据。但是,因为精力所限,这个解析器的接口不够友好,没来得及优化。在1.9中,json解析器的接口进行了大幅度的重新处理,绝对方便易用。下面分两部分解释。

一、将数据对象转化为 json 字符串

最常见的用途,是在传递数据的时候。你往往需要将服务器内存中的“数据对象”,先转化为 json 格式的字符串,然后才能传递给客户端,比如浏览器。

而转换的办法其实很简单,完全可以不使用任何框架或工具,直接拼接字符串,比如有这样一个“对象”:


	User user = new User();
	user.Id = 8;
	user.Name = "zhangsan";
	user.Gender = 1;

然后,你需要转化为 json 字符串,可以这样拼接:

	String jsonStr = "{";
jsonStr += "Id:" + user.Id + ",";
	jsonStr += "Name:" + user.Name+ ",";
	jsonStr += "Gender:" + user.Gender;
	jsonStr += "}";


这样做没有任何问题,换成StringBuilder拼接也行……但都不是关键。

关键在于,你拼接的时候,非常容易出错,比如少了一个逗号啥的;比如字符串中有引号的时候忘记转义处理;比如……总之,很容易拼错。

现在, wojilu框架可以避免这些易错的拼接方式,非常简单,这样处理即可:



String jsonStr =  Json.ToString( user );

这个 ToString(Object obj) 方法,不仅可以将一般的对象转换成字符串,也可以将数组、 List<> 列表, Dictionary

字典等,转换成字符串。下面是一些例子:

转换数组


            string[] arr = new string[] {
                "123", "abc", "", "name"
            };

            string str = Json.ToString( arr );

转换 Hashtable

            Hashtable dic = new Hashtable();
            dic.Add( "name", "sunweb" );
            dic.Add( "age", 99 );
            dic.Add( "gender", "male" );

            string str = Json.ToString( dic, false );

转换Dictionary

            Dictionary<string, object> dic = new Dictionary<string, object>();
            dic.Add( "name", "sunweb" );
            dic.Add( "age", 99 );
            dic.Add( "gender", "male" );
            string str = Json.ToString( dic );

转换List

            List<string> list = new List<string>();
            list.Add( "123" );
            list.Add( "abc" );
            list.Add( "" );
            list.Add( "name" );
            string str = Json.ToString( list );

转换其他值

            string str = Json.ToString( 123 );
            Assert.AreEqual( str, "123" );
            str = Json.ToString( 12.33 );
            Assert.AreEqual( str, "12.33" );
            str = Json.ToString( -3.5 );
            Assert.AreEqual( str, "-3.5" );
            string str = Json.ToString( false );
            Assert.AreEqual( "false", str );
            str = Json.ToString( true );
            Assert.AreEqual( "true", str );


总之,凡是要构建json字符串的地方,都不建议手工拼接。

如果没有现成的对象,推荐使用Dictionary这样处理:

            Dictionary<string, object> dic = new Dictionary<string, object>();
            dic.Add( "name", "sunweb" );
            dic.Add( "age", 99 );
            dic.Add( "gender", "male" );

            String str = Json.ToString( dic );

如果你的.net版本是3.0或以上,还可以使用匿名类型,更加方便:

var x = new { id=8, name="zhangsan" };
String str = Json.ToString( x );

一般说来,将对象转化为字符串(或其他格式)的操作,可以用一个术语来表示,就是“序列化(serialize)”,初看这个术语,可能对没有相关知识背景的人来说,有些费解,但熟悉之后,应该就没问题了。

二、解析 json 字符串

1、直接解析 json 字符串

wojilu框架提供了 Json.Parse( String jsonStr ) 方法,以及ParseJson方法,可以解析json字符串,方便获取其中是的数据。

            string json = "{ \"Name\" : \"zhangsan\",  \"Gender\":\"male\", \"Age\":18 }";
            JsonObject obj = Json.ParseJson( json );

            Assert.AreEqual( 2, obj.Count );

            Assert.AreEqual( "zhangsan", obj.Get( "Name" ) );
            Assert.AreEqual( "male", obj.Get( "Gender" ) );
            Assert.AreEqual( 18, obj.Get<int>( "Age" ) );

在获取属性的值的时候,Get("propertyName") 可以获取字符串,如果要获取其他类型,请使用Get<T>

()方法。比如上面的 obj.Get<int>( "Age" ) 。支持 int, string, bool, long, decimal, double, DateTime, JsonObject, List一共9种类型。

如果解析一个对象列表,可以用 Json.ParseList<T> 方法:


            string str = @"
[
{ Id:3, Name:""zhangsan"", Age:25 },
{ Id:5, Name:""lisi"", Age:18 }
]
";

            List<JsonObject> lists = Json.ParseList<JsonObject>( str );
            Assert.AreEqual( 2, lists.Count );

            // 弱类型获取值
            JsonObject obj = lists[0];
            Assert.AreEqual( 3, obj.Keys.Count );
            Assert.AreEqual( 3, obj["Id"] );
            Assert.AreEqual( "zhangsan", obj["Name"] );
            Assert.AreEqual( 25, obj["Age"] );

            // 强类型获取值
            Assert.AreEqual( 3, obj.Get<int>( "Id" ) );
            Assert.AreEqual( "zhangsan", obj.Get( "Name" ) );
            Assert.AreEqual( 25, obj.Get<int>( "Age" ) );

            JsonObject obj2 = lists[1];
            Assert.AreEqual( 5, obj2.Get<int>( "Id" ) );
            Assert.AreEqual( "lisi", obj2.Get( "Name" ) );
            Assert.AreEqual( 18, obj2.Get<int>( "Age" ) );

下面是一个综合的示例:

            // 解析对象
            string str = @"
{    
    name : ['蒋介石', 'Chiang Kai-shek',  '常凯申'],
    age : 125,
    gender : 'male',
    hasGun : true,
    birthday : '1887-10-31',
    wife : {
        name : '宋美龄',
        birthday : '1897-3-5'
    },
    friends : [
        {name:'sun', address:'xxxxxxxxxxxxx1' },
        {name:'mao', address:'xxxxxxxxxxxxx2' },
        {name:'dai', address:'xxxxxxxxxxxxx3' }
    ],
    other : 993439419349934,
    other2 : 88.99,
    other3 : [ 123, 'kkkkk',  {p1:'p1-value', p2:'p2-value' }]
}
";
            JsonObject obj = Json.ParseJson( str );

            List<String> names = obj.GetList<String>( "name" );
            Assert.AreEqual( 3, names.Count );
            Assert.AreEqual( "蒋介石", names[0] );
            Assert.AreEqual( "Chiang Kai-shek", names[1] );
            Assert.AreEqual( "常凯申", names[2] );

            Assert.AreEqual( 125, obj.Get<int>( "age" ) );

            Assert.AreEqual( "male", obj.Get( "gender" ) );
            Assert.IsTrue( obj.Get<bool>( "hasGun" ) );

            DateTime birthday = obj.Get<DateTime>( "birthday" );
            Assert.AreEqual( 1887, birthday.Year );
            Assert.AreEqual( 10, birthday.Month );
            Assert.AreEqual( 31, birthday.Day );

            JsonObject wife1 = obj.GetJson( "wife" );
            Assert.AreEqual( "宋美龄", wife1.Get( "name" ) );
            // GetJson( "wife" ) 等效于 Get<JsonObject>( "wife" )
            JsonObject wife2 = obj.Get<JsonObject>( "wife" );
            Assert.AreEqual( "宋美龄", wife2.Get( "name" ) );

            DateTime wifeBirthday = wife1.Get<DateTime>( "birthday" );

            Assert.AreEqual( 1897, wifeBirthday.Year );
            Assert.AreEqual( 3, wifeBirthday.Month );
            Assert.AreEqual( 5, wifeBirthday.Day );

            List<JsonObject> friends = obj.GetList<JsonObject>( "friends" );

            Assert.AreEqual( "sun", friends[0].Get( "name" ) );
            Assert.AreEqual( "xxxxxxxxxxxxx1", friends[0].Get( "address" ) );

            Assert.AreEqual( "mao", friends[1].Get( "name" ) );
            Assert.AreEqual( "xxxxxxxxxxxxx2", friends[1].Get( "address" ) );

            Assert.AreEqual( "dai", friends[2].Get( "name" ) );
            Assert.AreEqual( "xxxxxxxxxxxxx3", friends[2].Get( "address" ) );

            Assert.AreEqual( 993439419349934, obj.Get<long>( "other" ) );
            Assert.AreEqual( 88.99, obj.Get<decimal>( "other2" ) );

            // 因为列表内的数据类型不一致 ,所以此处只能GetList() 而不是泛型方法 GetList<T>()
            List<Object> list3 = obj.GetList( "other3" );
            Assert.AreEqual( 123, list3[0] );
            Assert.AreEqual( "kkkkk", list3[1] );

            JsonObject obj3 = list3[2] as JsonObject;
            Assert.AreEqual( "p1-value", obj3.Get( "p1" ) );
            Assert.AreEqual( "p2-value", obj3.Get( "p2" ) );

            // 解析数组
            str = "[ 'xxx1', 88, false, {name:'孙中山', gender:'male' }]";
            List<Object> list = Json.ParseList( str );
            //List<Object> list = Json.Deserialize( str ) as List<Object>;

            Assert.AreEqual( 4, list.Count );
            Assert.AreEqual( "xxx1", list[0] );
            Assert.AreEqual( 88, list[1] );
            Assert.AreEqual( false, list[2] );

            JsonObject j = list[3] as JsonObject;
            Assert.AreEqual( "孙中山", j.Get( "name" ) );
            Assert.AreEqual( "male", j.Get( "gender" ) );

            // 解析其它类型
            string json = "376";
            Assert.AreEqual( 376, Json.Parse( json ) );

            json = " false";
            Assert.AreEqual( false, Json.Parse( json ) );


2、将 json 字符串反序列化

对于一个 json 字符串,如果你有对应的类型class,那么,你可以将json字符串直接解析成"强类型"的对象,这个过程,我们称之为“反序列化”。

wojilu框架中提供了 Json.Deserialize<T>

( String jsonStrin ) 方法。比如:



            string str = "{Id:2,  Name:\"诺基亚n78\", Weight:300, Owner:{Id:88,Name:\"ownerName\",Age:\"999\"}}";

            MyPhone phone = Json.Deserialize<MyPhone>( str );

            Assert.IsNotNull( phone );
            Assert.AreEqual( 88, phone.Owner.Id );
            Assert.AreEqual( "ownerName", phone.Owner.Name );
            Assert.AreEqual( "999", phone.Owner.Age );

如果要反序列化一个列表,可以使用  Json.DeserializeList<T>

( String jsonStrin ) 方法。比如:


            String str = "  [1, 2, 3, 6, 8]  ";
            List<int> list = Json.DeserializeList<int>( str );
            Assert.AreEqual( 5, list.Count );
            Assert.AreEqual( 2, list[1] );
            Assert.AreEqual( 3, list[2] );
            Assert.AreEqual( 6, list[3] );
            Assert.AreEqual( 8, list[4] );

            str = "  [\"zhangsan\", \"lisi\", \"孙中山\", \"袁世凯\"]  ";
            List<String> strList = Json.DeserializeList<String>( str );
            Assert.AreEqual( 4, strList.Count );
            Assert.AreEqual( "zhangsan", strList[0] );
            Assert.AreEqual( "lisi", strList[1] );
            Assert.AreEqual( "孙中山", strList[2] );
            Assert.AreEqual( "袁世凯", strList[3] );

            str = @"
[
	{ Id:1, Name:""新闻大事001"", Weight:1 },
	{ Id:2, Name:""新闻大事002"", Weight:2 },
	{ Id:3, Name:""新闻大事003"", Weight:3 },
	{ Id:4, Name:""新闻大事004"", Weight:4 }
]";
            List<MyPhone> xlist = Json.DeserializeList<MyPhone>( str );
            Assert.AreEqual( 4, xlist.Count );

            Assert.AreEqual( 1, xlist[0].Id );
            Assert.AreEqual( "新闻大事001", xlist[0].Name );

            Assert.AreEqual( 2, xlist[1].Id );
            Assert.AreEqual( "新闻大事002", xlist[1].Name );

            Assert.AreEqual( 3, xlist[2].Id );
            Assert.AreEqual( "新闻大事003", xlist[2].Name );

            Assert.AreEqual( 4, xlist[3].Id );
            Assert.AreEqual( "新闻大事004", xlist[3].Name );

下面是一个综合的示例,我们先看类型定义:

    public class TJEntity {

        // 支持 7 种基础类型 int, string, decimal, long, double, bool, DateTime
        // 其中 long 会被序列化为字符串
        public int Id { get; set; }
        public string Name { get; set; }
        public decimal TMoney { get; set; }
        public long Area { get; set; }
        public double TDouble { get; set; }
        public bool IsBlack { get; set; }
        public DateTime Created { get; set; }

        // 支持其他对象
        public TPhone TPhone { get; set; }

        // 也支持原始 JsonObject 对象
        public JsonObject JsonObject { get; set; }

        // 支持List泛型
        public List<int> Id_List { get; set; }
        public List<string> Name_List { get; set; }
        public List<decimal> TMoney_List { get; set; }
        public List<long> Area_List { get; set; }
        public List<double> TValue_List { get; set; }
        public List<bool> IsBlack_List { get; set; }
        public List<DateTime> Created_List { get; set; }

        // 支持数组
        public TPhone[] TPhone_Array { get; set; }

        // 支持List泛型
        public List<TPhone> TPhone_List { get; set; }

        // 支持Dictionary泛型,但key必须是String类型
        public Dictionary<String, TPhone> TPhone_Dic { get; set; }

    }

整个“序列化”和“反序列化”过程是:

            TJEntity x = new TJEntity();
            x.Id = 2;
            x.Name = "x02";
            x.TMoney = 2.92M;
            x.Area = 22222222222222222L;
            x.TDouble = 22222.2222222299;
            x.IsBlack = true;
            x.Created = DateTime.Now.AddDays( -2 );

            x.TPhone = new TPhone { Id = 1, Name = "p01", Weight = 11 };
            x.JsonObject = new JsonObject();
            x.JsonObject.Add( "key1", "v1" );
            x.JsonObject.Add( "key2", "v2" );

            x.Id_List = new List<int> { 3, 4, 5 };
            x.Name_List = new List<string> { "x03", "x04", "x05" };
            x.TMoney_List = new List<decimal> { 3.93M, 4.94M, 5.95M };
            x.Area_List = new List<long> { 3333333333333333333L, 444444444444444444L, 555555555555555555L };
            x.TValue_List = new List<double> { 33333.2222222299, 44444.2222222299, 55555.2222222299 };
            x.IsBlack_List = new List<bool> { false, true, false };
            x.Created_List = new List<DateTime> { DateTime.Now.AddDays( -3 ), DateTime.Now.AddDays( -4 ), DateTime.Now.AddDays( -5 ) };

            x.TPhone_List = new List<TPhone> {
                new TPhone { Id=2, Name = "p02", Weight=22 },
                new TPhone { Id=3, Name = "p03", Weight=33 },
                new TPhone { Id=4, Name = "p04", Weight=44 }
            };

            x.TPhone_Dic = new Dictionary<string, TPhone>();
            x.TPhone_Dic.Add( "phone5", new TPhone { Id = 5, Name = "p05", Weight = 55 } );
            x.TPhone_Dic.Add( "phone6", new TPhone { Id = 6, Name = "p06", Weight = 66 } );
            x.TPhone_Dic.Add( "phone7", new TPhone { Id = 7, Name = "p07", Weight = 77 } );

            x.TPhone_Array = new TPhone[] {
                new TPhone { Id=7, Name = "p07", Weight=77 },
                new TPhone { Id=8, Name = "p08", Weight=88 },
                new TPhone { Id=9, Name = "p09", Weight=99 }
            };


            String jsonString = Json.ToString( x );
            Console.WriteLine( jsonString );

            // 反序列化测试
            TJEntity k = Json.Deserialize<TJEntity>( jsonString );
            Assert.IsNotNull( k );

            // 基础类型的属性
            Assert.AreEqual( x.Id, k.Id );
            Assert.AreEqual( x.Name, k.Name );
            Assert.AreEqual( x.Area, k.Area );

            Assert.AreEqual( x.TMoney, k.TMoney );
            Assert.AreEqual( x.TDouble, k.TDouble );
            Assert.AreEqual( x.IsBlack, k.IsBlack );
            Assert.IsTrue( isTimeEqual( x.Created, k.Created) );

            // 其他对象类型
            Assert.IsNotNull( k.TPhone );
            Assert.AreEqual( x.TPhone.Id, k.TPhone.Id );
            Assert.AreEqual( x.TPhone.Name, k.TPhone.Name );
            Assert.AreEqual( x.TPhone.Weight, k.TPhone.Weight );

            // 原始 JsonObject 对象
            Assert.IsNotNull( k.JsonObject );
            Assert.AreEqual( "v1", k.JsonObject.Get( "key1" ) );
            Assert.AreEqual( "v2", k.JsonObject.Get( "key2" ) );

            // List列表属性
            Assert.AreEqual( x.Id_List.Count, k.Id_List.Count );
            Assert.AreEqual( x.Id_List[0], k.Id_List[0] );
            Assert.AreEqual( x.Id_List[1], k.Id_List[1] );
            Assert.AreEqual( x.Id_List[2], k.Id_List[2] );

            Assert.AreEqual( x.Name_List.Count, k.Name_List.Count );
            Assert.AreEqual( x.Name_List[0], k.Name_List[0] );
            Assert.AreEqual( x.Name_List[1], k.Name_List[1] );
            Assert.AreEqual( x.Name_List[2], k.Name_List[2] );

            Assert.AreEqual( x.Area_List.Count, k.Area_List.Count );
            Assert.AreEqual( x.Area_List[0], k.Area_List[0] );
            Assert.AreEqual( x.Area_List[1], k.Area_List[1] );
            Assert.AreEqual( x.Area_List[2], k.Area_List[2] );

            Assert.AreEqual( x.TMoney_List.Count, k.TMoney_List.Count );
            Assert.AreEqual( x.TMoney_List[0], k.TMoney_List[0] );
            Assert.AreEqual( x.TMoney_List[1], k.TMoney_List[1] );
            Assert.AreEqual( x.TMoney_List[2], k.TMoney_List[2] );

            Assert.AreEqual( x.TValue_List.Count, k.TValue_List.Count );
            Assert.AreEqual( x.TValue_List[0], k.TValue_List[0] );
            Assert.AreEqual( x.TValue_List[1], k.TValue_List[1] );
            Assert.AreEqual( x.TValue_List[2], k.TValue_List[2] );

            Assert.AreEqual( x.IsBlack_List.Count, k.IsBlack_List.Count );
            Assert.AreEqual( x.IsBlack_List[0], k.IsBlack_List[0] );
            Assert.AreEqual( x.IsBlack_List[1], k.IsBlack_List[1] );
            Assert.AreEqual( x.IsBlack_List[2], k.IsBlack_List[2] );

            Assert.AreEqual( x.Created_List.Count, k.Created_List.Count );
            Assert.IsTrue( isTimeEqual( x.Created_List[0], k.Created_List[0] ) );
            Assert.IsTrue( isTimeEqual( x.Created_List[1], k.Created_List[1] ) );
            Assert.IsTrue( isTimeEqual( x.Created_List[2], k.Created_List[2] ) );

            // List<TypedObject>属性
            Assert.AreEqual( x.TPhone_List.Count, k.TPhone_List.Count );
            Assert.AreEqual( x.TPhone_List[0].Id, k.TPhone_List[0].Id );
            Assert.AreEqual( x.TPhone_List[0].Name, k.TPhone_List[0].Name );
            Assert.AreEqual( x.TPhone_List[0].Weight, k.TPhone_List[0].Weight );

            // Array<TypedObject>属性
            Assert.AreEqual( x.TPhone_Array.Length, k.TPhone_Array.Length );
            Assert.AreEqual( x.TPhone_Array[0].Id, k.TPhone_Array[0].Id );
            Assert.AreEqual( x.TPhone_Array[0].Name, k.TPhone_Array[0].Name );
            Assert.AreEqual( x.TPhone_Array[0].Weight, k.TPhone_Array[0].Weight );

            // Dictionary<String, TypedObject>属性
            Assert.AreEqual( x.TPhone_Dic.Count, k.TPhone_Dic.Count );
            foreach (KeyValuePair<String, TPhone> kv in x.TPhone_Dic) {
                Assert.AreEqual( kv.Value.Id, k.TPhone_Dic[kv.Key].Id );
                Assert.AreEqual( kv.Value.Name, k.TPhone_Dic[kv.Key].Name );
                Assert.AreEqual( kv.Value.Weight, k.TPhone_Dic[kv.Key].Weight );
            }

另外,如果你的.net版本是3.0或以上,也可以使用Json.DeserializeAnonymous “反序列化”为匿名类型。

var x = new { id=8, name="zhangsan" };
var obj = Json.DeserializeAnonymous( jsonString, x.GetType() );

// 或者
var obj = Json.DeserializeAnonymous( jsonString, new {id=0, name=""} );

【总结一下】
1、将对象转换成json字符串,使用 Json.ToString( obj ) 方法;
2、解析json字符串,获取弱类型的数据,使用 Json.Parse(str) 和 Json.ParseList(str) 方法;
3、解析json字符串,获取强类型的数据,使用Json.Deserialize<T>

(str) 和 Json.DeserializeList<T>() 方法。

更多方法,请参看源码注释,以及测试文件。

三、在 web 项目中使用 json

1、直接使用 echoJson( Object obj ) 即可,比如:


	public class xxxController : ControllerBase {
	
		public void Index() {
			// 你的其他代码,查询数据等……
			List<User> list = xxxx;
			echoJson( list );
		}
	}

这个 echoJson( Object obj ) 方法,会先将对象转化成(序列化)字符串,然后输出到客户端。
除了一般的对象,你也可以直接在参数中传入字符串。
当然,基于前面的理由(手工拼接容易出错),不推荐你直接拼接字符串。

2、使用视图对象

如果一个领域对象,比如User有20个属性,你在转化成json字符串的时候,有时候并不需要全部转化。比如,你在网页中,只需要展示User的Id,Name,Gender三个属性,那么,你这样传输:

	User user = xxxx获取User对象……;
	echoJson( user );

其实是将多余的数据也传递给了客户端,既不必要,也往往不合理(泄露了太多数据)。

这时候,我们往往再建立一个“值对象(value object)”或者“视图对象(view object)”,不管你怎么称呼吧,我们创建这样一个中间对象 UserVo :

public class UserVo {

	public UserVo( User user ) {
		this.Id = user.Id;
		this.Name = user.Name;
		if( user.Gender==1 ) {
			this.Gender = "男";
		}
		else if( user.Gender==0) {
			this.Gender = "女";
		}
		else {
			this.Gender = "保密";
		}
	}

	public int Id {get;set;}
	public String Name {get;set;}
	public String Gender {get;set;}
}

然后,这样传输数据:

	User user = xxxx获取User对象……;
	UserVo userVo = new UserVo( user );
	echoJson( userVo );

就可以把User中多余的、或者不相干的数据过滤掉。当然,如果只是一次或临时使用,也不必建立vo,看具体情况而定。另外,如果.net是3.0或以上,推荐使用匿名类型,会更加方便。

var x = new { id=8, name="zhangsan" };
echoJson( x );


【在线演示、代码示例】http://www.wojilu.com/Demo/JsonTest/JsonTest.aspx 

本帖于 2013/8/8 12:45:10 被 掷鸡蛋者 最后编辑
关键词 json, jsonp 修改tag
相关文章
而死,不默而生
freebird
发表于: 2013/3/21 8:32 引用 回复 只看该作者 2# TOP
江湖新秀
性别: 男
积分:239
阅读权限:194
帖子: 32
加入时间: 2012/4/13
最后登录: 2018/5/4

josnp能否加入呢

掷鸡蛋者
发表于: 2013/3/21 9:00 引用 回复 只看该作者 3# TOP
管理员
性别: 男
积分:52169
阅读权限:43381
帖子: 8316
加入时间: 2010/4/29
最后登录: 2019/3/3

对于jsonp,服务端可以这样做:

List<User> list = xxxx等查询代码;
var jsonStr = string.Format( "{0}({1})", ctx.Get( "callback" ), Json.ToString( list ) );

echoJson( jsonStr );
客户端代码jquery已经内置,这样:

$.ajax({
    dataType: 'jsonp',
    url: '你的服务端网址',
    jsonp: 'callback',
    success: function (data) { 客户端处理代码 }
});

本帖于 2013/3/22 13:11:47 被 掷鸡蛋者 最后编辑
而死,不默而生
动漫
发表于: 2013/3/21 10:54 引用 回复 只看该作者 4# TOP
江湖新秀
性别: 保密
积分:128
阅读权限:63
帖子: 19
加入时间: 2013/1/23
最后登录: 2013/6/17

 很详细    

能跟你结婚不能跟你圆房
hzhla
发表于: 2013/3/21 14:12 引用 回复 只看该作者 5# TOP
版主
性别: 男
积分:1160
阅读权限:1354
帖子: 390
加入时间: 2011/9/11
最后登录: 2018/8/20

 正式版才有是吧

hzhla
发表于: 2013/3/21 14:12 引用 回复 只看该作者 6# TOP
版主
性别: 男
积分:1160
阅读权限:1354
帖子: 390
加入时间: 2011/9/11
最后登录: 2018/8/20
什么时候有正式版啊
wt0731
发表于: 2013/3/21 22:27 引用 回复 只看该作者 7# TOP
江湖豪侠
性别: 男
积分:1308
阅读权限:841
帖子: 176
加入时间: 2010/4/29
最后登录: 2015/10/21
 顶, 有前瞻性!
迈入人生关键时期! 我运营的网站http://www.djhnjllm.com/
imneo
发表于: 2013/3/21 22:55 引用 回复 只看该作者 8# TOP
版主
性别: 保密
积分:1083
阅读权限:1256
帖子: 278
加入时间: 2012/4/10
最后登录: 2013/10/25

 是否支持匿名类呢?比如直接new  { id=1,name=xx }?这样比构造dict方便多了。

掷鸡蛋者
发表于: 2013/3/22 19:48 引用 回复 只看该作者 9# TOP
管理员
性别: 男
积分:52169
阅读权限:43381
帖子: 8316
加入时间: 2010/4/29
最后登录: 2019/3/3

确实,匿名类比dict方便,这个建议非常好,十分感谢

序列化原先没问题;反序列化刚才调了一下,也最终开发完成。

下面是测试代码:

// 创建一个匿名对象
var obj1 = new {

    // 基本类型
    id = 2,
    name = "zhangsan",
    age = 18,
    money = 2.92M,
    area = 22222222222222222L,
    tdouble = 22222.2222222299,
    isBlack = true,
    created = DateTime.Now.AddDays( -2 ),

    // 匿名对象
    phone = new {
        id = 38,
        name = "xphone",
        weight = 88,

        // 匿名对象的匿名对象
        company = new { Name = "google", price = 2999, rank = 10 }
    },

    // 数组
    arrInt = new int[] { 2, 6, 9 },
    arrString = new String[] { "s1", "s3", "s6" },
    TPhone_Array = new TPhone[] {
        new TPhone { Id=7, Name = "p07", Weight=77 },
        new TPhone { Id=8, Name = "p08", Weight=88 },
        new TPhone { Id=9, Name = "p09", Weight=99 }
    },

    // 列表
    names = new List<string> { "x03", "x04", "x05" },
    TPhone_List = new List<TPhone> {
        new  TPhone{ Id=2, Name = "p02", Weight=22 },
        new  TPhone{ Id=3, Name = "p03", Weight=33 },
        new  TPhone{ Id=4, Name = "p04", Weight=44 }
    }
};

// 序列化“匿名类型”
String str1 = Json.ToString( obj1 );
Console.WriteLine( str1 );

// 反序列化“匿名类型”
var obj2 = Json.DeserializeAnonymous( str1, obj1.GetType() );
String str2 = Json.ToString( obj2 );

Assert.AreEqual( str1, str2 );

而死,不默而生
动漫
发表于: 2013/3/23 15:07 引用 回复 只看该作者 10# TOP
江湖新秀
性别: 保密
积分:128
阅读权限:63
帖子: 19
加入时间: 2013/1/23
最后登录: 2013/6/17
什么时候有正式版啊
hzhla at 2013-3-21 14:12

 蛋蛋说是这个月底 出来

能跟你结婚不能跟你圆房

快速回复主题