Get/Post请求

通常情况下，GET请求用于读操作，POST请求用于写操作（通常包括更新、创建和删除）

http://www.cnblogs.com/tangge/p/6230757.html#t0

public static class RequestHelper
    {
        private static readonly string ConfigString =
            System.Configuration.ConfigurationManager.ConnectionStrings["WebApi"].ConnectionString;

        /// <summary>
        /// POST请求,有参数，返回对象T
        /// </summary>
        /// <typeparam name="T">泛型对象T</typeparam>
        /// <param name="url">api请求url</param>
        /// <param name="postDataStr">泛型对象</param>
        /// <returns></returns>
        public static T PostT<T>(string url, T postDataStr)
        {
            try
            {
                //将对象转为json数据  Newtonsoft.Json 
                //注意：日期类型的转换为json时，使用下面方法可避免出错
                var str = JsonConvert.SerializeObject(postDataStr);

                //创建实例
                var request = (HttpWebRequest) WebRequest.Create(ConfigString + url);
                request.Method = "POST";
                request.ContentType = "application/json;charset=UTF-8";
                //写入
                var myRequestStream = request.GetRequestStream();
                var myStreamWriter = new StreamWriter(myRequestStream, Encoding.UTF8);
                myStreamWriter.Write(str.ToCharArray());
                myStreamWriter.Flush();
                //读取
                var response = (HttpWebResponse) request.GetResponse();
                var myResponseStream = response.GetResponseStream();
                var myJson = string.Empty;
                if (myResponseStream != null)
                    using (var sr = new StreamReader(myResponseStream, Encoding.UTF8))
                    {
                        myJson = sr.ReadToEnd();
                    }
                //json转为对象
                var result = JsonConvert.DeserializeObject<T>(myJson);
                return result;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
        }

        /// <summary>
        /// POST请求，有参数，返回Object
        /// </summary>
        /// <param name="url">api请求url</param>
        /// <param name="postDataStr">object参数</param>
        /// <returns></returns>
        public static object PostObject(string url, object postDataStr)
        {
            try
            {
                //将对象转为json数据  Newtonsoft.Json 
                //注意：日期类型的转换为json时，使用下面方法避免出错
                var str = JsonConvert.SerializeObject(postDataStr);

                //创建实例
                var request = (HttpWebRequest) WebRequest.Create(ConfigString + url);
                request.Method = "POST";
                request.ContentType = "application/json;charset=UTF-8";
                //写入
                var myRequestStream = request.GetRequestStream();
                var myStreamWriter = new StreamWriter(myRequestStream, Encoding.UTF8);
                myStreamWriter.Write(str.ToCharArray());
                myStreamWriter.Flush();
                //读取
                var response = (HttpWebResponse) request.GetResponse();
                var myResponseStream = response.GetResponseStream();
                var myJson = string.Empty;
                if (myResponseStream != null)
                    using (var sr = new StreamReader(myResponseStream, Encoding.UTF8))
                    {
                        myJson = sr.ReadToEnd();
                    }
                //json转为对象
                var result = JsonConvert.DeserializeObject<object>(myJson);
                return result;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
        }

        /// <summary>
        /// POST请求，返回泛型T对象
        /// </summary>
        /// <typeparam name="T">泛型T对象</typeparam>
        /// <param name="url">api请求的url</param>
        /// <param name="postDataStr">请求参数</param>
        /// <returns></returns>
        public static T PostString<T>(string url, string postDataStr)
        {
            try
            {
                var urlStr = ConfigString + url + "?" + postDataStr;
                var client = new HttpClient();
                HttpContent content = new StringContent(postDataStr);
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                var response = client.PostAsync(urlStr, content).Result;

                var myJson = response.Content.ReadAsStringAsync().Result;
                //json转为对象
                var result = JsonConvert.DeserializeObject<T>(myJson);
                return result;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
        }

        /// <summary>
        /// POST请求，有参数，无返回值
        /// </summary>
        /// <param name="url">api请求的url</param>
        /// <param name="postDataStr">请求参数</param>
        public static void PostString(string url, string postDataStr)
        {
            try
            {
                var urlStr = ConfigString + url + "?" + postDataStr;
                var client = new HttpClient();
                HttpContent content = new StringContent(postDataStr);
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                client.PostAsync(urlStr, content);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
        }

        /// <summary>
        /// POST请求，无参数,返回T
        /// </summary>
        /// <typeparam name="T">返回的T对象</typeparam>
        /// <param name="url">api请求的url</param>
        /// <returns></returns>
        public static T HostPost<T>(string url)
        {
            try
            {
                var request = (HttpWebRequest) WebRequest.Create(ConfigString + url);
                request.Method = "POST";
                request.ContentType = "application/json";
                request.ContentLength = 0; //post请求必须带参数，如果无参数请设置为0

                var response = (HttpWebResponse) request.GetResponse();
                var myResponseStream = response.GetResponseStream();
                var myJson = string.Empty;
                if (myResponseStream != null)
                    using (StreamReader sr = new StreamReader(myResponseStream, Encoding.UTF8))
                    {
                        myJson = sr.ReadToEnd();
                    }
                var result = JsonConvert.DeserializeObject<T>(myJson);
                return result;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
        }

        /// <summary>
        /// GET请求，无参数，返回T
        /// </summary>
        /// <typeparam name="T">返回的T对象</typeparam>
        /// <param name="url">api请求的url</param>
        /// <returns></returns>
        public static T HostGet<T>(string url)
        {
            try
            {
                var request = (HttpWebRequest) WebRequest.Create(ConfigString + url);
                request.Method = "GET";
                request.ContentType = "application/json;charset=UTF-8";

                var response = (HttpWebResponse) request.GetResponse();
                var myResponseStream = response.GetResponseStream();
                var myJson = string.Empty;
                if (myResponseStream != null)
                    using (var sr = new StreamReader(myResponseStream, Encoding.UTF8))
                    {
                        myJson = sr.ReadToEnd();
                    }
                var result = JsonConvert.DeserializeObject<T>(myJson);
                return result;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
        }

        /// <summary>
        /// GET请求，有参数，返回对象T
        /// </summary>
        /// <typeparam name="T">返回的T对象</typeparam>
        /// <param name="url">api请求的url</param>
        /// <param name="objectParam">请求参数</param>
        /// <returns></returns>
        public static T HostGet<T>(string url, object objectParam)
        {
            try
            {
                var request = (HttpWebRequest) WebRequest.Create(ConfigString + url + "?" + objectParam);
                request.Method = "GET";
                request.ContentType = "application/json;charset=UTF-8";
                var response = (HttpWebResponse) request.GetResponse();
                var myResponseStream = response.GetResponseStream();
                var myJson = string.Empty;
                if (myResponseStream != null)
                    using (var sr = new StreamReader(myResponseStream, Encoding.UTF8))
                    {
                        myJson = sr.ReadToEnd();
                    }
                var result = JsonConvert.DeserializeObject<T>(myJson);
                return result;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
        }

        /// <summary>
        /// GET请求，有参数，返回对象object
        /// </summary>
        /// <param name="url">api请求的url</param>
        /// <param name="objectParam">请求参数</param>
        /// <returns></returns>
        public static object GetObject(string url, object objectParam)
        {
            try
            {
                var request = (HttpWebRequest) WebRequest.Create(ConfigString + url + "?" + objectParam);
                request.Method = "GET";
                request.ContentType = "application/json;charset=UTF-8";
                var response = (HttpWebResponse) request.GetResponse();
                var myResponseStream = response.GetResponseStream();
                var myJson = string.Empty;
                if (myResponseStream != null)
                    using (var sr = new StreamReader(myResponseStream, Encoding.UTF8))
                    {
                        myJson = sr.ReadToEnd();
                    }
                var result = JsonConvert.DeserializeObject(myJson);
                return result;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
        }
    }