webapi返回json日期带t_webapi 返回json带下划线 - CSDN
精华内容
参与话题
  • WebApi自带json序列化对遇到时间日期字段的时候,到前端获取的格式总是为“ 2016-07-14T15:32:44”,中间总是会一个T,显然不是很友好。先是偷懒在园子里边去找一些解决方案,尝试了一下,然并卵。于是,自己想...

     WebApi自带json序列化对遇到时间日期字段的时候,到前端获取的格式总是为“ 2016-07-14T15:32:44”,中间总是会带一个T,显然不是很友好。先是偷懒在园子里边去找一些解决方案,尝试了一下,然并卵。于是,自己想办法。

                1.先是查看ApiController.JsonResults<T>的源码

               

               其实Json<T>方法是有三个重载方法的,我们只需要在返回对象的时候调用重载方法,加上序列化对象serializerSettings参数即可,该对象的获取可以通过

                

               GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings 来进行获取,我们默认看到的该参数就是"yyyy'-'MM'-'dd'T'HH':'mm':'ss",那么显而易见,最后的格式带T就事这个参数的问题。我们只需要对这个参数重新赋值为"yyyy'-'MM'-'dd' 'HH':'mm':'ss"即可。由于这个参数是一个全局参数,我们可以在WebAPi的Register中定义并且赋值,这样就不用在每个方法里边都重新赋值了。

              

             到此处,该问题算是完美解决了,但是有没有办法不要每个方法都加序列化的参数,程序员都是爱偷懒的。但是肯定有的。其实很简单,分析JsonResult<T>的源码即可发现该方法是可以被重写的。只需要在基类方法中重写即可。基类重写如下:

               

               重写基类方法后需要注意的是,该方法由于返回值是JsonResult,也会被当做API方法,默认都是POST方法,会替换掉没有Route特性的方法,所以临时加了个HttpGet特性。此处还有待完善。项目中碰到的问题,记录一下,欢迎大家拍砖!

     

    --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

     园子里边的解决方案: 

    引用自:http://www.cnblogs.com/wuball/p/4231343.html

    ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------      

    MVC web api 返回JSON的几种方式

    1、在WebApiConfig的Register中加入以下代码

    config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));

    2、在WebApiConfig的Register中加入以下代码

    config.Formatters.Remove(config.Formatters.XmlFormatter);

    3、在WebApiApplication的Application_Start中加入以下代码

    GlobalConfiguration.Configuration.Formatters.XmlFormatter.SupportedMediaTypes.Clear();

     

    1、在MVC中全局去除时间格式中带T的问题。

    MVC中默认使用Newtonsoft.Json序列化的,所以在WebApiConfig的Register中加入以下代码即可

    GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new IsoDateTimeConverter
                 {
                     DateTimeFormat = "yyyy'-'MM'-'dd' 'HH':'mm':'ss"
                 });

    2、在webservice中去除时间带T的问题。

    复制代码
    复制代码
    IsoDateTimeConverter timejson = new IsoDateTimeConverter
          {
              DateTimeFormat = "yyyy'-'MM'-'dd' 'HH':'mm':'ss"
          };
     //在序列化的时候传入timejson对象
     //如:
     return JsonConvert.SerializeObject(object, timejson);//object是需要序列化的对象
    复制代码
    复制代码
    展开全文
  • web api中,系统会自动将返回的对象序列化为json数据,但是如果对象中含有时间的话,序列化后的时间中会含有“T”字符,如下: [csharp] view plain copy   public object getJson()  {   var ...

    web api中序列化后的时间中含有“T”的解决方法


    原来的以下内容只解决了序列化的问题,但作为参数反序列时,会有不完全对应格式将不能正确得到日期的问题。

    以下为完美方法:

    1、在WebApiConfig.cs的Register方法中加入以下语句,插入自定义的JsonDateTimeConverter格式

    GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.Converters.Insert(
                    0, new JsonDateTimeConverter());


    2、新建一个类,名为JsonDateTimeConverter.cs,重写IsoDateTimeConverter的ReadJson方法,内容如下

        /// <summary>
        /// Json日期带T格式转换
        /// </summary>
        public class JsonDateTimeConverter : IsoDateTimeConverter
        {
            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
            {
                DateTime dataTime;
                if (DateTime.TryParse(reader.Value.ToString(), out dataTime))
                {
                    return dataTime;
                }
                else
                {
                    return existingValue;
                }
            }
    
            public JsonDateTimeConverter()
            {
                DateTimeFormat = "yyyy-MM-dd HH:mm:ss";
            }
        }



    OK,到此完美解决。


    以下为原来内容:

    web api中,系统会自动将返回的对象序列化为json数据,但是如果对象中含有时间的话,序列化后的时间中会含有“T”字符,如下:

    [csharp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. public object getJson()  
    2. {  
    3.     var rst = new  
    4.     {  
    5.         name = "abc",  
    6.         time = DateTime.Now  
    7.     };  
    8.   
    9.     return rst;  
    10. }  

    返回后返回的json代码如下:

    [html] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. {  
    2.     "name": "abc",  
    3.     "time": "2015-02-10T15:18:21.7046433+08:00"  
    4. }  

    web api返回的是标准格式时间,但是我们平常并不需要标准格式的时间,那么我们如何修改返回的数据的时间格式呢?

     

    web api中,我们可以在WebApiConfig.csRegister函数中新增以下配置来定义返回的时间类型格式,如下:

    [csharp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. //配置返回的时间类型数据格式  
    2. GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.Converters.Add(  
    3.     new Newtonsoft.Json.Converters.IsoDateTimeConverter()  
    4.     {  
    5.         DateTimeFormat = "yyyy-MM-dd hh:mm:ss"  
    6.     }  
    7. );  

    DateTimeFormat中的格式即是我们自定义的时间格式,定义后我们再访问getJson接口看看返回的数据会怎样,如下:

    [html] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. {  
    2.     "name": "abc",  
    3.     "time": "2015-02-10 03:26:14"  
    4. }  

    哈哈,变成了我们常用的格式了


    来源:http://blog.csdn.net/soldierluo/article/details/43703743

    展开全文
  • WebApi接口 - 响应输出xml和json

    千次阅读 2018-05-05 17:21:58
    WebApi接口 - 响应输出xml和json格式化数据这东西,主要看需要的运用场景,今天和大家分享的是webapi格式化数据,这里面的例子主要是输出json和xml的格式数据,测试用例很接近实际常用情况;希望大家喜欢,也希望...

    WebApi接口 - 响应输出xml和json


    格式化数据这东西,主要看需要的运用场景,今天和大家分享的是webapi格式化数据,这里面的例子主要是输出json和xml的格式数据,测试用例很接近实际常用情况;希望大家喜欢,也希望各位多多扫码支持和点赞谢谢:

    . 自定义一个Action,响应输出集合数据

    . api返回json数据的两种方式

    . json时间格式处理方式

    . 让api接口支持返回json和xml数据

    下面一步一个脚印的来分享:

    . 自定义一个Action,响应输出集合数据

    首先,我们新建一个webapi项目,新建好以后我们能够找到 Controllers/ValuesController.cs 文件,查看里面有自动生成的一些代码,我们先不管;然后我们创建一个学生 MoStudent 类,属性代码如:

     1 public class MoStudent
     2     {
     3         public DateTime Birthday { get; set; }
     4 
     5         public int Id { get; set; }
     6 
     7         public string Name { get; set; }
     8 
     9         public bool Sex { get; set; }
    11     }

    然后我们在 ValuesController 中初始化一些公共的数据,代码如:

    1  public List<MoStudent> students = new List<MoStudent>() { 
    2         
    3              new MoStudent{ Id =1 , Name ="小1", Sex = true, Birthday= Convert.ToDateTime("1991-05-31")},
    4              new MoStudent{ Id =2 , Name ="小2", Sex = false, Birthday= Convert.ToDateTime("1991-05-31")},
    5              new MoStudent{ Id =3 , Name ="小3", Sex = false, Birthday= Convert.ToDateTime("1991-05-31")},
    6              new MoStudent{ Id =4 , Name ="小4", Sex = true, Birthday= Convert.ToDateTime("1991-05-31")}
    7         };

    再来,我们新创建一个 GetAllStudents01() 方法,并输出学生集合数据,代码如:

    1  public List<MoStudent> GetAllStudents01()
    2         {
    3             return students;
    4         }

    这个时候我们生成一下项目,然后在浏览器访问下地址为: http://localhost:1001/api/values ,此时会提示一个错误信息:

    这个错误信息是该地址同时匹配上了两个api的Action,分别为 Get()和GetAllStudents01() 两个方法,这种错误我们应该怎么处理呢;一种可以删除其中一个方法;二种方式是在默认路由设置下Action,然后通过具体的Controller/Action地址来访问;三种是通过Route修改下对应的访问路由(这种方法前面一篇文章已经有说明);这里我们就使用第二种,先来修改下 WebApiConfig.cs 文件中默认路由的配置,修改后的配置如:

    1 config.Routes.MapHttpRoute(
    2                 name: "DefaultApi",
    3                 routeTemplate: "api/{controller}/{action}/{id}",
    4                 defaults: new { id = RouteParameter.Optional }
    5             );

    生成后,我们在浏览器中这样访问: http://localhost:1001/api/values/GetAllStudents01 ,GetAllStudents01是对应要访问的Action名称,不出意外我们能在浏览器中看到如下结果:

    webapi能正常返回数据了,但是地址感觉好长的样子,不利于我们测试,那么下么我们使用上一篇文章用到的标记RoutePrefixRoute来变动下路由,增加的代码如:

    然后我们测试访问下该地址: http://localhost:1001/s/all01 能正常返回如上面的截图数据;

     

    . api返回json数据的两种方式

     首先,我们回顾下看下上面节点例子的截图,接口响应输出的是xml格式的数据,这里默认采用的是webapi自带的xml格式化方式,把 Student 属性全部展示了出来,我们真实开发接口的时候,通常会有些对象的属性不会展示,下面我们通过增加 DataContract 和 DataMember 来设置把不需要暴露的属性“隐藏掉”,我们先来看先增加了这两个标记后的Student实体:

     1 [DataContract]
     2     public class MoStudent
     3     {
     4         [DataMember]
     5         public DateTime Birthday { get; set; }
     6 
     7         [DataMember]
     8         public int Id { get; set; }
     9 
    10         [DataMember]
    11         public string Name { get; set; }
    12 
    13         [DataMember]
    14         public bool Sex { get; set; }
    15 
    16     }

    然后咋们运行下程序,在页面看到的结果信息和之前的结果一模一样:

    下面把 Birthday 属性上面的 DataMember 去掉,然后再来运行查看结果:

    可以看到输出的结果中已经没有了这个 Birthday ,这里能看出的结果是如果未标记 DataMember ,那么是不会输出来的;我们再来看一个有用的东西,先吧Birthday的DataMember回复,然后修改成如下代码:

     1 [DataContract]
     2     public class MoStudent
     3     {
     4         [DataMember(Order = 3)]
     5         public DateTime Birthday { get; set; }
     6 
     7         [DataMember(Order = 0)]
     8         public int Id { get; set; }
     9 
    10         [DataMember(Order = 1)]
    11         public string Name { get; set; }
    12 
    13         [DataMember(Order = 2)]
    14         public bool Sex { get; set; }
    15 
    16     }

    然后咋们再运行起来看效果图:

    相信仔细的朋友能够发现,此时Birthday数据暂时的位置已经从第一个变到了最后一个,没错这就是DataMember中Order属性参数的效果:用来指定显示输出数据的位置;

    好了咋们来看正题,webapi返回json数据这里讲解两种,一种是使用自带的Json格式化方式,使用方法只需要在 Global.asax.cs 文件中清除一下默认的xml输出方式即可,代码如:

    在全局设置中,把所有返回的格式清除,设置JSON。所有的返回的xml格式都会被清除

    在WebApiConfig类的Register方法中,我们添加下面代码:

    config.Formatters.Clear();
    config.Formatters.Add(new JsonMediaTypeFormatter());

    因为webapi在启动的时候,默认格式化数据有两种方式xml和json,而xml是其默认的启动方式,所以这里是需要清除了xml格式化,那么另外只剩下json,所以咋们在运行程序后能看到这样的结果输出:

    结果返回了json数据,如果咋们想要如上面xml一样吧Birthday隐藏掉,我们同样也可以使用 DataContract 和 DataMember 来做这效果,删除Birthday对应的 DataMember 标记后,咋们能看到这样的效果:

    同理,我们把Birthday的DataMember还原,然后指定Order属性值 [DataMember(Order=1)] ,这样Birthday显示的位置就变动了:

    好了这试第一种json格式化的方式,下面来看下用使用Json.Net怎么来格式化,为了避免影响效果,我们把 Global.asax.cs 文件还原,然后重新增加一个Action方法,代码如:

     1 [Route("all01_1")]
     2         public async Task<HttpResponseMessage> GetAllStudents01_1()
     3         {
     4             var result = await JsonConvert.SerializeObjectAsync(students);
     5 
     6             return new HttpResponseMessage
     7             {
     8                 Content = new StringContent(result),
     9                 StatusCode = HttpStatusCode.OK
    10             };
    11         }

    这里用到了Json.Net的 JsonConvert.SerializeObjectAsync 方法来格式化成字符串,然后传递给 HttpResponseMessage ,最终输出的效果和上面一样,好了咋们也来看看这种方式怎么来隐藏不希望接口暴露的属性,这里我们用 JsonIgnore 标记,测试用例在实体类中修改如:

    1 [JsonIgnore]
    2 public DateTime Birthday { get; set; }

    然后运行看一下效果:

    我们再来看一下怎么来设置属性的排序,可以使用 JsonProperty(Order = 1) ,实体类修改的代码如下:

     1 public class MoStudent
     2     {
     3         //[DataMember(Order = 1)]
     4         [JsonProperty(Order = 1)]
     5         public DateTime Birthday { get; set; }
     6 
     7         //[DataMember(Order = 0)]
     8         [JsonProperty(Order = 0)]
     9         public int Id { get; set; }
    10 
    11         //[DataMember(Order = 1)]
    12         [JsonProperty(Order = 1)]
    13         public string Name { get; set; }
    14 
    15         //[DataMember(Order = 2)]
    16         [JsonProperty(Order = 2)]
    17         public bool Sex { get; set; }
    18 
    19     }

    能得到和DataMember设置的一样的结果:

     

    . json时间格式处理方式

    要说时间格式化,我们通常的生日格式如:yyyy-MM-dd这样,下面也分别对刚才上面两种json化出来的时间做格式化;先来看Json.net,我们先来定义一个名称为 SelfDateTimeFormat 的类并且继承 DateTimeConverterBase 类,然后需要重写 ReadJson和WriteJson ,下面看下这个类的全部方法:

     1  /// <summary>
     2         /// 自定义时间格式化
     3         /// </summary>
     4         public class SelfDateTimeFormat : DateTimeConverterBase
     5         {
     6             public IsoDateTimeConverter TimeConvert = null;
     7 
     8             public SelfDateTimeFormat() {
     9 
    10                 TimeConvert = new IsoDateTimeConverter
    11                 {
    12                     DateTimeFormat = "yyyy-MM-dd"
    13                 };
    14             }
    15 
    16             public SelfDateTimeFormat(string formatter = "yyyy-MM-dd HH:mm:ss")
    17             {
    18 
    19                 TimeConvert = new IsoDateTimeConverter
    20                 {
    21                     DateTimeFormat = formatter
    22                 };
    23             }
    24 
    25             public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
    26             {
    27 
    28                 return TimeConvert.ReadJson(reader, objectType, existingValue, serializer);
    29             }
    30 
    31             public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
    32             {
    33 
    34                 TimeConvert.WriteJson(writer, value, serializer);
    35             }
    36         }

    然后我们需要在实体类的时间属性上增加这样的标记: [JsonConverter(typeof(OverridClass.SelfDateTimeFormat))] ,这里的 SelfDateTimeFormat 就是咋们刚才定义的自定义格式化时间类,我们来看一下输出的效果数据:

    好了,咋们再来看webapi自带的json格式化如何定义一个日期格式的数据,我们需要在Global.asax.cs中增加如下代码:

    1 var format = GlobalConfiguration.Configuration.Formatters;
    2             format.JsonFormatter.SerializerSettings.DateFormatString = "yyyy.MM.dd";

    没错,只需要如此简单的代码,即可时间格式化成:

     

    . 让api接口支持返回json和xml数据

    开篇第一小节已经有简单说明webapi有自己的json和xml格式化处理,这里们来设置通过参数请求返回不同的数据格式;首先还是需要在Global中设置如下代码:

    1  var format = GlobalConfiguration.Configuration.Formatters;
    2             format.JsonFormatter.SerializerSettings.DateFormatString = "yyyy.MM.dd";
    3 
    4             //清除默认xml
    5             format.XmlFormatter.SupportedMediaTypes.Clear();
    6          
    7             //通过参数设置返回格式
    8             format.JsonFormatter.MediaTypeMappings.Add(new QueryStringMapping("t", "json", "application/json"));
    9             format.XmlFormatter.MediaTypeMappings.Add(new QueryStringMapping("t", "xml", "application/xml"));

    这里用到了 QueryStringMapping 类,并传递给他构造函数的参数 new QueryStringMapping("t","json""application/json") 和 new QueryStringMapping("t""xml""application/xml") 这样就分别对用了json和xml,而前面的“t”表示请求的url地址中参数名称t,下面我们分别来测试下两种请求的参数,地址分别为:

     http://localhost:1001/s/all01?t=xml 

     

     http://localhost:1001/s/all01?t=json 

     

    展开全文
  • Some programmers are tring to get or post multiple parameters on a WebApi controller, then they will find it not easy to solve it clearly, actually, there is a simple and pragmatical solution if we

    前言

    阅读本文之前,您也可以到Asp.Net Web API 2 系列导航进行查看 http://www.cnblogs.com/aehyok/p/3446289.html

    本文描述ASP.NET Web API中的JSON和XML格式化器。

    在ASP.NET Web API中,媒体类型格式化器(Media-type Formatter)是一种能够做以下工作的对象:

    • 从HTTP消息体读取CLR(公共语言运行时)对象
    • 将CLR对象写入HTTP消息体

    Web API提供了用于JSON和XML的媒体类型格式化器。框架已默认将这些格式化器插入到消息处理管线之中。客户端在HTTP请求的Accept报头中可以请求JSON或XML。

    JSON媒体类型格式化器

     JSON格式化是由JsonMediaTypeFormatter类提供的。默认情况下,JsonMediaTypeFormatter使用Json.NET库执行序列化工作。Json.NET是一个第三方开源项目。

    如果喜欢,你可以将JsonMediaTypeFormatter配置成使用DataContractJsonSerializer来代替Json.NET。要想这么做,只需UseDataContractJsonSerializer将属性设置为true即可:

    var json = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
    json.UseDataContractJsonSerializer = true;

    JSON序列化

    本小节描述,在使用默认的Json.NET序列化器时,JSON格式化器的一些特定行为。这并不意味着要包含Json.NET库的整个文档。更多信息参阅Json.NET Documentation。

    什么会被序列化?

    默认情况下,所有public属性和字段都会被包含在序列化的JSON中。为了忽略一个属性或字段,需要用JsonIgnore注解属性修饰它。

    复制代码
    public class Product
    {
        public string Name { get; set; }
        public decimal Price { get; set; }
    
        [JsonIgnore]
        public int ProductCode { get; set; } // omitted
    }
    复制代码

    如果你更喜欢“opt-in(选入)”方法,可以用DataContract注解属性来修饰类。如果有注解属性,则成员均被忽略,除非有DataMemberDataMember也可以序列化private成员。

    复制代码
    [DataContract]
    public class Product
    {
        [DataMember]
        public string Name { get; set; }
    
        [DataMember]
        public decimal Price { get; set; }
        public int ProductCode { get; set; }  // omitted by default
    }
    复制代码

    只读属性

    只读属性默认是序列化的。

    Dates(日期)

    默认情况下,Json.NET会将日期写成ISO 8601格式。UTC(Coordinated Universal Time — 世界标准时间)格式的日期书写时带有后缀“Z”。本地时间格式的日期包括了一个时区偏移量。例如:

    2012-07-27T18:51:45.53403Z         // UTC(标准时间)
    2012-07-27T11:51:45.53403-07:00    // Local(本地时间)

    默认情况下,Json.NET保留时区。通过设置DateTimeZoneHandling属性,可以重写这一行为:

    // Convert all dates to UTC
    // 将所有日期转换成UTC格式
    var json = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
    json.SerializerSettings.DateTimeZoneHandling =
         Newtonsoft.Json.DateTimeZoneHandling.Utc;

    如果你喜欢使用微软的JSON日期格式("\/Date(ticks)\/ ")而不是ISO 8601,可以在SerializerSettings上设置DateFormatHandling属性:

    var json = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
    json.SerializerSettings.DateFormatHandling =
        Newtonsoft.Json.DateFormatHandling.MicrosoftDateFormat;

    Indenting(缩进)

    为了书写有缩进的JSON,可以将Formatting设置为Formatting.Indented

    var json = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
    json.SerializerSettings.Formatting = 
        Newtonsoft.Json.Formatting.Indented; 

    Camel Casing(驼峰式大小写转换)

    为了在不修改数据模型的情况下,用驼峰式大小写转换JSON的属性名,可以设置序列化器上的CamelCasePropertyNamesContractResolver

    var json = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
    json.SerializerSettings.ContractResolver = 
        new CamelCasePropertyNamesContractResolver();

    匿名类型与弱类型对象

    动作方法或以返回一个匿名对象,并将其序列化成JSON。例如:

    复制代码
    public object Get()
    {
        return new { 
            Name = "Alice", 
            Age = 23, 
            Pets = new List<string> { "Fido", "Polly", "Spot" } 
        };
    }
    复制代码

    响应消息体将含有以下JSON:

    {"Name":"Alice","Age":23,"Pets":["Fido","Polly","Spot"]}

    如果Web API从客户端接收了松散结构的JSON,你可以将该请求体解序列化成Newtonsoft.Json.Linq.JObject类型。

    public void Post(JObject person)
    {
        string name = person["Name"].ToString();
        int age = person["Age"].ToObject<int>();
    }

    然而,通常更好的是使用强类型数据对象。那么,便不需要自行对数据进行解析,并且能得到模型验证的好处。

    XML序列化器不支持匿名类型或JObject实例。如果将这些特性用于JSON数据,应该去掉管线中的XML格式化器,如本文稍后描述的那样。

    XML媒体类型格式化器

      XML格式化是由XmlMediaTypeFormatter类提供的。默认情况下,XmlMediaTypeFormatter使用DataContractSerializer类来执行序列化。如果喜欢,你可以将XmlMediaTypeFormatter配置成使用XmlSerializer而不是DataContractSerializer。要想这么做,可将UseXmlSerializer属性设置为true 

    var xml = GlobalConfiguration.Configuration.Formatters.XmlFormatter;
    xml.UseXmlSerializer = true;

    XmlSerializer类支持的类型集要比DataContractSerializer更窄一些,但对结果XML有更多的控制。如果需要与已有的XML方案匹配,可考虑使用XmlSerializer

    XML Serialization——XML序列化

     本小节描述使用默认DataContractSerializer的时,XML格式化器的一些特殊行为。默认情况下,DataContractSerializer行为如下:

    •   序列化所有public读/写属性和字段。为了忽略一个属性或字段,请用IgnoreDataMember注解属性修饰它。
    •   private和protected成员不作序列。
    •   只读属性不作序列化
    •   类名和成员名按类声明中的确切呈现写入XML
    •   使用XML的默认命名空间

    如果需要在序列化上的更多控制,可以用DataContract注解属性修饰类。当这个注解属性出现时,该类按以策略序列化:

    •   “Opt in(选入)”方法:属性与字段默认不被序列化。为了序列化一个属性或字段,请用DataMember注解属性修饰它。
    •   要序列化private或protected成员,请用DataMember注解属性修饰它。
    •   只读属性不被序列化。
    •   要改变类名在XML中的呈现,请在DataContract注解属性中设置Name参数。
    •   要改变成员名在XML中的呈现,请设置DataMember注解属性中的Nmae参数。
    •   要改变XML命名空间,请设置DataContract类中的Namespace参数。

     

    Read-Only Properties——只读属性

    只读属性是不被序列化的。如果只读属性有一个支撑private字段,可以用DataMember注解属性对这个private字段进行标记。这种办法需要在类上使用DataContract注解属性。

    复制代码
    [DataContract]
    public class Product
    {
        [DataMember]
        private int pcode;  // serialized(序列化的)
    
        // Not serialized (read-only)
        // 不作序列化(只读)
        public int ProductCode { get { return pcode; } }
    }
    复制代码

    Dates——日期

    日期被写成ISO 8601格式。例如,“2012-05-23T20:21:37.9116538Z”。

    Indenting——缩进

    要书写缩进的XML,请将Indent属性设置为true

    var xml = GlobalConfiguration.Configuration.Formatters.XmlFormatter;
    xml.Indent = true; 

    设置每一类型(Per-Type)的XML序列化器

    你可以为不同的CLR类型设置不同的XML序列化器。例如,你可能有一个特殊的数据对象,它出于向后兼容而需要XmlSerializer。你可以为此对象使用XmlSerializer,而对其它类型继续使用DataContractSerializer

    为了设置用于特殊类型的XML序列化器,要调用SetSerializer

    var xml = GlobalConfiguration.Configuration.Formatters.XmlFormatter;
    // Use XmlSerializer for instances of type "Product":
    // 对“Product”类型的实例使用XmlSerializer:
    xml.SetSerializer<Product>(new XmlSerializer(typeof(Product)));

    你可以指定一个XmlSerializer,或任何派生于XmlObjectSerializer的对象。

    Removing the JSON or XML Formatter——去除JSON或XML格式化器

     你可以从格式化器列表中删除JSON格式化器,或XML格式化器,只要你不想使用它们。这么做的主要原因是:

    •    将你的Web API响应限制到特定的媒体类型。例如,你可能决定只支持JSON响应,而删除XML格式化器。
    •    用一个自定义格式化器代替默认的格式化器。例如,你可能要用自己的自定义JSON格式化器实现来代替(默认的)JSON格式化器。

     以下代码演示了如何删除默认的格式化器。在Global.asax中定义的Application_Start方法中调用它。

    复制代码
    void ConfigureApi(HttpConfiguration config)
    {
        // Remove the JSON formatter
        // 删除JSON格式化器
        config.Formatters.Remove(config.Formatters.JsonFormatter);
    
        // or(或者)
    
        // Remove the XML formatter
        // 删除XML格式化器
        config.Formatters.Remove(config.Formatters.XmlFormatter);
    }
    复制代码

    Handling Circular Object References——处理循环对象引用

     在默认情况下,JSON和XML格式化器将所有对象都写成值。如果两个属性引用了同一个对象,或者,如果在一个集合同一个对象出现了两次,格式化器将对此对象做两次序列化。这是在对象图含有循环的情况下会出现的特有问题,因为,序列化器在检测到对象图中的循环时,会抛出异常。

    考虑以下对象模型和控制器。

    复制代码
    public class Employee
    {
        public string Name { get; set; }
        public Department Department { get; set; }
    }
    
    public class Department
    {
        public string Name { get; set; }
        public Employee Manager { get; set; }
    }
    
    public class DepartmentsController : ApiController
    {
        public Department Get(int id)
        {
            Department sales = new Department() { Name = "Sales" };
            Employee alice = new Employee() { Name = "Alice", Department = sales };
            sales.Manager = alice;
            return sales;
        }
    }
    复制代码

    调用此动作会触发格式化器抛出异常,该异常将转换成发送给客户端的状态代码500(内部服务器错误)响应。

    为了保留JSON中的对象引用,对Global.asax文件的Application_Start方法添加以下代码:

    var json = GlobalConfiguration.Configuration.Formatters.JsonFormatter;
    json.SerializerSettings.PreserveReferencesHandling = 
        Newtonsoft.Json.PreserveReferencesHandling.All;

    现在,此控制器动作将返回类似于如下形式的JSON:

    {"$id":"1","Name":"Sales","Manager":{"$id":"2","Name":"Alice","Department":{"$ref":"1"}}}

    注意,序列化器对两个对象都添加了一个“$id”。而且,它检测到Employee.Department属性产生了一个循环,因此,它用一个对象引用{"$ref":"1"}代替这个值。

    对象引用是不标准的JSON。在使用此特性之前,要考虑你的客户端是否能够解析这种结果。简单地去除对象图中的循环,可能是更好的办法。例如,此例中Employee链接回Department并不是真正的需要。

    为了保留XML中的对象引用,可以使用两个选项。较简单的选项是对模型类添加[DataContract(IsReference=true)]。IsReference参数启用了对象引用。记住,DataContract构成了序列化的“选入(Opt-in)”,因此,你还需要对属性添加DataMember注解属性:

    复制代码
    [DataContract(IsReference=true)]
    public class Department
    {
        [DataMember]
        public string Name { get; set; }
    
        [DataMember]
        public Employee Manager { get; set; }
    }
    复制代码

    现在,该格式化器将产生类似于如下形式的XML:

    复制代码
    <Department xmlns:i="http://www.w3.org/2001/XMLSchema-instance" z:Id="i1" 
                xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/" 
                xmlns="http://schemas.datacontract.org/2004/07/Models">
        <Manager>
            <Department z:Ref="i1" />
            <Name>Alice</Name>
        </Manager>
        <Name>Sales</Name>
    </Department>
    复制代码

    如果想避免在模型类上使用注解属性,还有另一个选项:创建新的类型专用的DataContractSerializer实例,并在构造器中将preserveObjectReferences设置为true

    var xml = GlobalConfiguration.Configuration.Formatters.XmlFormatter;
    var dcs = new DataContractSerializer(typeof(Department), null, int.MaxValue,
        false, /* preserveObjectReferences: */ true, null);
    xml.SetSerializer<Department>(dcs);

    Testing Object Serialization——测试对象序列化

     在设计Web API时,对如何序列化对象进行测试是有用的。不必创建控制器或调用控制器动作,便可做这种事。

     

    复制代码
    string Serialize<T>(MediaTypeFormatter formatter, T value)
    {
        // Create a dummy HTTP Content.
        // 创建一个HTTP内容的哑元
        Stream stream = new MemoryStream();
        var content = new StreamContent(stream);
    
        // Serialize the object.
        // 序列化对象
        formatter.WriteToStreamAsync(typeof(T), value, stream, content.Headers, null).Wait();
    
        // Read the serialized string.
        // 读取序列化的字符串
        stream.Position = 0;
        return content.ReadAsStringAsync().Result;
    }
    
    T Deserialize<T>(MediaTypeFormatter formatter, string str) where T : class
    {
        // Write the serialized string to a memory stream.
        // 将序列化的字符器写入内在流
        Stream stream = new MemoryStream();
        StreamWriter writer = new StreamWriter(stream);
        writer.Write(str);
        writer.Flush();
        stream.Position = 0;
    
        // Deserialize to an object of type T
        // 解序列化成类型为T的对象
        return formatter.ReadFromStreamAsync(typeof(T), stream, null, null).Result as T;
    }
    
    // Example of use
    // 使用示例(用例)
    void TestSerialization()
    {
        var value = new Person() { Name = "Alice", Age = 23 };
    
        var xml = new XmlMediaTypeFormatter();
        string str = Serialize(xml, value);
    
        var json = new JsonMediaTypeFormatter();
        str = Serialize(json, value);
    
        // Round trip
        // 反向操作(解序列化)
        Person person2 = Deserialize<Person>(json, str);
    }
    复制代码

    总结

     本课主要简单的了解一下JSON和XML的序列化和反序列的使用。

     本文的参考链接为 http://www.asp.net/web-api/overview/formats-and-model-binding/json-and-xml-serialization

     同时本文已更新至 Web API导航系列 http://www.cnblogs.com/aehyok/p/3446289.html

    展开全文
  • 1、WebApiConfig类 MVC中默认使用Newtonsoft.Json序列化的,所以在WebApiConfig的...//格式化json数据中的时间的T var jsontimeset = GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerS...
  • WebApi自带json序列化对遇到时间日期字段的时候,到前端获取的格式总是为“ 2016-07-14T15:32:44”,中间总是会一个T,显然不是很友好。先是偷懒在园子里边去找一些解决方案,尝试了一下,然并卵。于是,自己想...
  • 数据接口-免费版(股票数据API

    万次阅读 2018-04-14 15:56:22
    获取股票数据的源头主要有:数据超市、雅虎、新浪、Google、和讯、搜狐、ChinaStockWebService、东方财富客户端、证券之星、网易财经。数据超市2016年5月6日更新。根据最近频繁出现的数据超市,可以无限制获取相关...
  • 接口测试 | 接口测试入门

    万次阅读 多人点赞 2019-07-25 20:08:13
    应用程序接口(API, application programming interface)测试, 数据库测试。 实际上意义就是UI界面到数据库之间,数据流经过的所有过程。 LAMP(Linux Apache MySQL PHP)/LNMP(Linux Nginx MySQL PHP)...
  • 股票数据API整理

    万次阅读 2016-11-10 21:23:41
    最近在做股票分析系统,数据获取源头成了一大问题,经过仔细的研究发现了很多获取办法,这里整理一下,方便后来者使用。 获取股票数据的源头主要有:数据超市、雅虎、新浪、Google、和讯、搜狐、...
  • 本人新手,在.Net中写WebAPI的时候,当接口返回json数据含有日期时间类型的字段时,总是在日期和时间中夹着一个字母T;微软这么设置可能有其内在的初衷,但是对于我来说,这样的格式不是很方便,前端同学展示出来...
  • 当数据库字段为date类型时,@ResponseBody注解在转换...我们在使用springmvc中的 @ResponseBody 注解返回JSON时可以配置Json转换器如下: &lt;!-- 日期处理时间类 --&gt; &lt;bean id="jsonUti...
  • MySQL 中 TIMESTAMP 类型返回日期时间数据中T 一、场景描述: MySQL 中使用 TIMESTAMP 类型 实体类使用 java.util.Date 类型 返回 JSON 数据: 二、通过注解格式化(方法一) 可以在日期类型属性上,或者 GET ...
  • Jackson API 详细汇总 与 使用介绍

    万次阅读 2020-07-18 21:58:07
    目录 jackson 概述 开发实战 ...日期序列化 jackson 概述 1、市面上用于在 Java 中解析 Json 的第三方库,随便一搜不下几十种,其中的佼佼者有Google 的 Gson,Alibaba 的 Fastjson以及本文的...
  •  在使用asp.net mvc 结合jquery esayui做一个系统,但是在使用使用this.json方法直接返回一个json对象,在列表中显示时发现datetime类型的数据在转为字符串是它默认转为Date(84923838332223)的格式,在经过查资料...
  • 使用JSON进行数据传输的总结

    万次阅读 2011-06-16 18:04:00
    为了更好的使用ajax,我们将学习一种有用的数据格式 JavaScript Object Notation(JSON),以及如何使用它更轻松地在应用程序中移动数据和对象。JSON是一种简单的数据交换格式,在某些方面,它的作用与XML非常类似,...
  • Spring Boot 内置了jackson来完成JSON的序列化和反序列化操作。Jackson使用ObjectMapper类将POJO对象序列化成JSON字符串,也能将JSON字符串反序列化成POJO对象。 JackSon支持三种层次的序列化和反序列化方式: ...
  • 股票数据抓取接口文章转载

    千次阅读 2017-11-21 09:58:28
    http://blog.csdn.net/xp5xp6/article/details/53121481 ... ...最近在做股票分析系统,数据获取源头成了一大问题,经过仔细的研究发现了很多获取办法,这里整理一下,方便后来者使用。...获取股票数据的源头主要有
1 2 3 4 5 ... 20
收藏数 7,812
精华内容 3,124
关键字:

webapi返回json日期带t