HttpHelper类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Xml;
using System.Collections.Specialized;
using EntityModel;
using CommonLibrary.Constant;
using System.Threading.Tasks;

namespace CommuService
{
    /// <summary>
    /// 服务访问类
    /// </summary>
    public class HttpHelper
    {
        private WebClient _client=null;
        public HttpHelper(string contentType = "application/x-www-form-urlencoded",string encodingName="utf-8")
        {
            try
            {
                 _client= CreateWebClient(contentType,encodingName);
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        private WebClient CreateWebClient(string contentType,string encodingName)
        {
          return new WebClient()
                {
                    Encoding = Encoding.GetEncoding(encodingName),
                    Headers =  ((Func<string,WebHeaderCollection>) 
                        ((type)=> 
                        {
                             var headers= new WebHeaderCollection();
                             headers.Add(HttpRequestHeader.ContentType,type);
                            
                             return headers;
                        }
                        )).Invoke(contentType),
                };
        }

        //public HttpResultInfo UploadValues(string url, NameValueCollection values, string currentType, string method = "POST")
        /// <summary>
        /// WebClient.UploadValuesvalue方法重新封装
        /// 会阻塞当前调用“该方法”的线程
        public HttpResultInfo UploadValues(string url, NameValueCollection values,string method = "POST")
        {
            try
            {
                if (_client != null)
                {
                    byte[] result = _client.UploadValues(url, method, values);
                    string xml = _client.Encoding.GetString(result);
                    return this.CreateResultInfo(xml);
                }
                else
                {
                    return null;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// WebClient 服务 异步请求方法封装，
        /// 会创建新子线程来处理请求
        /// </summary>
        /// public async Task<HttpResultInfo> UploadValuesTaskAsync(string url, NameValueCollection values, string currentType, string method = "POST")
        public async Task<HttpResultInfo> UploadValuesTaskAsync(string url, NameValueCollection values,string method = "POST")
        {
            try
            {
                Task<byte[]> taskResult = _client.UploadValuesTaskAsync(url, method, values);
                byte[] result = await taskResult;
                Func<byte[],Task<HttpResultInfo>> asynResultInfo = async (res) =>
                    {
                        await Task.Delay(TimeSpan.FromMilliseconds(100));
                        string xml = _client.Encoding.GetString(res);
                        return this.CreateResultInfo(xml);
                    };
                return await asynResultInfo(result);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// WebClient 服务 异步请求方法封装，
        /// 会创建新子线程来处理请求
        /// </summary>
        public async Task<HttpResultInfo> UploadDataTaskAsync(string url, byte[] bytes, string method = "POST")
        {
            try
            {
                Task<byte[]> taskResult = _client.UploadDataTaskAsync(url,method,bytes);
                byte[] result = await taskResult;
                Func<byte[], Task<HttpResultInfo>> asynResultInfo = async (res) =>
                {
                    await Task.Delay(TimeSpan.FromMilliseconds(100));
                    string xml = _client.Encoding.GetString(res);
                    return this.CreateResultInfo(xml);
                };
                return await asynResultInfo(result);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        //private HttpResultInfo CreateResultInfo(string xml, string currentType)
        private HttpResultInfo CreateResultInfo(string xml)
        {
            HttpResultInfo httpResult = new HttpResultInfo() { Inform = new Inform() };
            httpResult.XMLData = xml;
            try
            {
                XmlDocument xmlDoc = new XmlDocument();
                xmlDoc.LoadXml(xml);
                XmlElement rootElement = xmlDoc.DocumentElement;
                //首先校验XML文档根元素格式
                if (VerifyRootElementFormat(rootElement))
                {
                    //成功与失败，“返回结果”的XML文档结构不相同，
                    //但xml根节点必须包含result和message两个子节点
                    string result = rootElement.SelectSingleNode(XMLConst.Result).InnerText.Trim();
                    string message = rootElement.SelectSingleNode(XMLConst.Message).InnerText.Trim();
                    if (result == XMLConst.Failure)
                    {
                        httpResult.IsSuccess = false;
                    }
                    else if (result == XMLConst.Success)
                    {
                        //包括message元素有子节点和无子节点两种情况
                        httpResult.IsSuccess = true;
                    }
                    else
                    {
                        throw new Exception("XML交互文档的result节点内容不符合协议格式！");
                    }
                    //获得结果信息
                    httpResult.Inform.Result = result;
                    httpResult.Inform.Message = message;
                    //获得交互类型
                    httpResult.XMLInteractiveCode = rootElement.GetAttribute(XMLConst.Code).Trim();
                    return httpResult;
                }
                else
                {
                    throw new Exception("XML交互文档的根元素不符合协议格式！");
                }
            }
            catch (XmlException)
            {
                throw new Exception("服务端返回的XML格式错误，为：" + xml);
            }
            catch (System.Xml.XPath.XPathException exPath)
            {
                throw new Exception("服务端返回的XML节点错误，" + exPath.Message);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 验证交互文档的根元素语法格式（主要针对HTTP）
        /// </summary>
        private bool VerifyRootElementFormat(XmlElement rootElement)
        {
            //首先判断根节点
            if (rootElement == null || rootElement.Name != XMLConst.Information
                //|| !rootElement.HasAttribute(XMLConst.Code)
                //|| String.IsNullOrEmpty(rootElement.GetAttribute(XMLConst.Code).Trim())
                || rootElement.SelectSingleNode(XMLConst.Result) == null
                || rootElement.SelectSingleNode(XMLConst.Message) == null)
            {
                return false;
            }
            else//若根节点无误，则进一步判断是否为http请求返回的XML
            {
                return true;
            }
        }

    }

    /// <summary>
    /// 请求结果信息
    /// </summary>
    public class HttpResultInfo
    {
        public HttpResultInfo()
        {
            this.XMLData = string.Empty;
            this.IsSuccess = false;
        }

        /// <summary>
        /// 返回数据结果
        /// </summary>
        public string XMLData
        {
            get;
            set;
        }

        /// <summary>
        /// 请求是否成功
        /// </summary>
        public bool IsSuccess
        {
            get;
            set;
        }

        /// <summary>
        /// 该对象将被传递给完成异步操作时所调用的方法
        /// 回调方法或完成事件的处理方法
        /// </summary>
        public object UserToken
        {
            get;
            set;
        }

        /// <summary>
        /// http服务请求响应的消息
        /// </summary>
        public Inform Inform
        {
            get;
            set;
        }

        /// <summary>
        /// XML交互代码
        /// </summary>
        public string XMLInteractiveCode
        {
            get;
            set;
        }
    }
}