webapi 获取json数据

一般的我们可以直接使用参数来接受，这个就不多介绍了

    [HttpGet]
        public IHttpActionResult Test2([FromUri]string name)
        {
            object obj = new
            {
                name = "sss",
                age = ,
                sex = true
            };
            return Ok(new { errcode = , data = obj });
        }

        [HttpPost]
        public IHttpActionResult Test3([FromBody]string name)
        {
            throw new Exception("嘻嘻嘻");
        }

        /// <summary>
        /// 返回强类型
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        [HttpGet]
        public CommonOutDto Test4([FromUri]string name)
        {
            CommonOutDto outDto = new CommonOutDto();
            outDto.errcode = ;
            return outDto;
        } 

现在一般使用json来传递参数,如果使用强类型，需要我们把类的属性和参数名设置一样就可以了。get,post都可以，这里只演示了post请求

①使用参数名来接受，这样显示不管你是传递json字符串还是json对象都是接收不到的

 [HttpPost]
        public IHttpActionResult Test4([FromBody]string json)
        {
            throw new Exception("嘻嘻嘻");
        }

②稍微改动下，把参数类型换成objct，这样我们不管是传递json对象和字符串都是能够接受到的

 [HttpPost]
        public IHttpActionResult Test4([FromBody]object json)
        {
            throw new Exception("嘻嘻嘻");
        }

json对象；

json字符串：

正解：普通的两种使用方式

　　　　 /// <summary>
        /// 如果没有定义Dto类型
        /// </summary>
        /// <param name="json">json数据</param>
        /// <returns></returns>
        [HttpPost]
        public IHttpActionResult Test3([FromBody]object json)
        {
            JObject @object = JObject.Parse(json.ToString());

            return Ok(@object);
        }

        /// <summary>
        /// 定义了Dto类型
        /// </summary>
        /// <param name="inDto">
        /// 根据json 定义的类
        /// </param>
        /// <returns></returns>
        [HttpPost]
        public IHttpActionResult Test4(ToiletInfoInDto inDto)
        {
            // CommonOutDto 为自定义的返回类
            CommonOutDto outDto = new CommonOutDto();
            outDto.dataStr = "请求成功";
            outDto.errcode = ;
            return Ok(outDto);
        }

ToiletInfoInDto ：

  /// <summary>
    /// 厕所信息
    /// </summary>
    public class ToiletInfoInDto
    {
        /// <summary>
        /// 厕所编号
        /// </summary>
        public string CsNum { get; set; }

        /// <summary>
        /// 厕所名称
        /// </summary>
        public string CsName { get; set; }

        /// <summary>
        /// 百度经度
        /// </summary>
        public string CoordX { get; set; }

        /// <summary>
        /// 百度纬度
        /// </summary>
        public string CoordY { get; set; }     

        /// <summary>
        /// 厕所等级
        /// </summary>
        public string Rank { get; set; }
    }

CommonOutDto：

  /// <summary>
    /// 返回公共类
    /// </summary>
    public class CommonOutDto
    {
        public int errcode { get; set; }

        public string dataStr { get; set; }

        public string errmsgStr { get; set; }
    }

③mvc中也可以写接口，我们肯定使用过流接受过参数，那webapi中同样是可以的

mvc中可以直接写：

 string json2 = new StreamReader(Request.InputStream).ReadToEnd();

webapi中没有 HttpContext这个，我们可以引用进行使用

  //引用 using System.Web;
                string json2 = new StreamReader(HttpContext.Current.Request.InputStream).ReadToEnd();

webapi中我们使用request强制同步获取数据，显示获取不到

   //强制同步获取不到数据
                string aa = this.Request.Content.ReadAsStringAsync().GetAwaiter().GetResult();

推荐：使用异步的方式

        /// <summary>
        /// 使用objct接受
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IHttpActionResult> TestAsync([FromBody]object json)
        {
            JObject @object = JObject.Parse(json.ToString());
            return await Task.FromResult<IHttpActionResult>(Ok(@object));
        }

        /// <summary>
        /// 使用强类型接受
        /// </summary>
        /// <param name="inDto"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<IHttpActionResult> TestAsync2(ToiletInfoInDto inDto)
        {
            return await Task.FromResult<IHttpActionResult>(Ok(inDto));
        }

        /// <summary>
        /// 使用读取数据的方式
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        public async Task<IHttpActionResult> TestAsync3()
        {
            string aa = await this.Request.Content.ReadAsStringAsync();
            return await Task.FromResult<IHttpActionResult>(Ok(aa));
        }

        /// <summary>
        /// 使用强类型接受，返回强类型     推荐这种，输入，输出都新建一个对应的Dto进行处理
        /// </summary>
        /// <param name="inDto">输入类</param>
        /// <returns>输出类</returns>
        [HttpPost]
        public async Task<CommonOutDto> TestAsync4(ToiletInfoInDto inDto)
        {
            CommonOutDto outDto = new CommonOutDto();
            outDto.errcode = ;
            return await Task.FromResult(outDto);
        }

显示结果：

 

可以看到我们的 TestAsync2 接口中，我们的属性小写了，这是自己序列化json数据造成的，俗称：驼峰式。  当然这个是可以设置的，我们在webapiConfig.cs 中可以设置我们的json的属性

  public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {

            // Web API 配置和服务

            // Web API 路由
            config.MapHttpAttributeRoutes();
            //多添加一个action
            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{action}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
            // 干掉XML序列化器   两种都可以
            //GlobalConfiguration.Configuration.Formatters.XmlFormatter.SupportedMediaTypes.Clear();
            config.Formatters.Remove(config.Formatters.XmlFormatter);

            //配置json数据格式
            JsonMediaTypeFormatter jsonFormatter = config.Formatters.JsonFormatter;
            //忽略循环引用，如果设置为Error，则遇到循环引用的时候报错（建议设置为Error，这样更规范）
            jsonFormatter.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Error;
            //日期格式化，默认的格式也不好看
            jsonFormatter.SerializerSettings.DateFormatString = "yyyy-MM-dd HH:mm:ss";
            // 对 JSON 数据使用混合大小写。跟属性名同样的大小.输出
            jsonFormatter.SerializerSettings.ContractResolver = new DefaultContractResolver();
            //json中属性开头字母小写的驼峰命名
            //jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
        }
    }

总结：

1：一般的我们使用Object类型或者强类型来接接收

2:提高效率，我们是异步

题外：我们一般都会准备一个Dto来接受我们的json对象，如果你不想这样写，也可以使用JObject来用。