WebServiceCaller

WebServiceCaller

 /*  jonney 2015-09-19 */

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Net;
 using System.Text;
 using System.Xml;
 using System.Xml.Serialization;

 namespace Downloader
 {
     /// <summary>
     ///  利用WebRequest/WebResponse进行WebService调用的类
     /// </summary>
     public class WebServiceCaller
     {
         /// <summary>
         /// 需要WebService支持Get调用
         /// </summary>
         public static XmlDocument QueryGetWebService(String url, String methodName, Dictionary<string, object> pars)
         {
             var request = (HttpWebRequest)WebRequest.Create(url + "/" + methodName + "?" + ParsToString(pars));
             request.Method = "GET";
             request.ContentType = "application/x-www-form-urlencoded";
             SetWebRequest(request);
             return ReadXmlResponse(request.GetResponse());
         }

         /// <summary>
         /// 需要WebService支持Post调用
         /// </summary>
         public static XmlDocument QueryPostWebService(String url, String methodName, Dictionary<string, object> pars)
         {
             var request = (HttpWebRequest)WebRequest.Create(url + "/" + methodName);
             request.Method = "POST";
             request.ContentType = "application/x-www-form-urlencoded;";
             SetWebRequest(request);
             byte[] data = EncodePars(pars);
             WriteRequestData(request, data);
             return ReadXmlResponse(request.GetResponse());
         }

         /// <summary>
         /// 通用WebService调用(Soap),参数Pars为String类型的参数名、参数值
         /// </summary>
         public static XmlDocument QuerySoapWebService(String url, String methodName, Dictionary<string, object> pars)
         {
             if (XmlNamespaces.ContainsKey(url + methodName))
             {
                 string[] echo = XmlNamespaces[url + methodName].ToString().Split('`');
                 string xmlNs = echo[];
                 string xmlSoapAction = echo[];
                 return QuerySoapWebService(url, methodName, pars, xmlNs, xmlSoapAction);
             }
             string soapAction = "";
             string nameSpace = GetNamespace(url, methodName, ref soapAction);
             return QuerySoapWebService(url, methodName, pars, nameSpace, soapAction);
         }

         /// <summary>
         /// 需要WebService支持Post调用,返回Json
         /// </summary>
         public static string QueryPostWebService(String endPoint, StringBuilder postData)
         {
             var request = (HttpWebRequest)WebRequest.Create(endPoint);
             request.Method = "POST";
             request.ContentType = "application/json";
             SetWebRequest(request);
             byte[] data = Encoding.UTF8.GetBytes(postData.ToString());
             WriteRequestData(request, data);
             return ReadTxtResponse(request.GetResponse());
         }

         /// <summary>
         /// 需要WebService支持Post调用,返回字节流
         /// </summary>
         public static byte[] QueryPostWebService(String endPoint, string postData)
         {
             var request = (HttpWebRequest)WebRequest.Create(endPoint);
             request.Method = "POST";
             request.ContentType = "application/json";
             SetWebRequest(request);
             byte[] data = Encoding.UTF8.GetBytes(postData);
             WriteRequestData(request, data);

             using (var response = (HttpWebResponse)request.GetResponse())
             {
                 if (response.StatusCode != HttpStatusCode.OK)
                 {
                     var message = String.Format(CultureInfo.CurrentCulture, "Request failed. Received HTTP {0}", response.StatusCode);
                     throw new WebException(message);
                 }
                 using (var result = new MemoryStream())
                 {
                     const int bufferLen = ;
                     var buffer = new byte[bufferLen];
                     using (var responseStream = response.GetResponseStream())
                     {
                         var len = responseStream.Read(buffer, , bufferLen);
                         while (len > )
                         {
                             result.Write(buffer, , len);
                             len = responseStream.Read(buffer, , bufferLen);
                         }
                     }
                     return result.ToArray();
                 }
             }
         }

         private static XmlDocument QuerySoapWebService(String url, String methodName, Dictionary<string, object> pars, string xmlNs, string soapAction)
         {
             XmlNamespaces[url + methodName] = xmlNs + "`" + soapAction;//加入缓存，提高效率
             var request = (HttpWebRequest)WebRequest.Create(url);
             request.Method = "POST";
             request.ContentType = "text/xml; charset=utf-8;";
             string temSoapAction = "\"" + soapAction + "\"";
             request.Headers.Add("SOAPAction", temSoapAction);
             SetWebRequest(request);
             byte[] data = EncodeParsToSoap(pars, xmlNs, methodName);
             WriteRequestData(request, data);
             var doc2 = new XmlDocument();
             XmlDocument doc = ReadXmlResponse(request.GetResponse());
             var mgr = new XmlNamespaceManager(doc.NameTable);
             mgr.AddNamespace("soap", "http://schemas.xmlsoap.org/soap/envelope/");
             var xmlNode = doc.SelectSingleNode("//soap:Body/*", mgr);
             if (xmlNode != null)
             {
                 String retXml = xmlNode.InnerXml;
                 doc2.LoadXml("<root>" + retXml + "</root>");
             }
             else throw new SystemException("Get soap:Body null");
             AddDelaration(doc2);
             return doc2;
         }

         private static string GetNamespace(String url, string method, ref string pSoapAction)
         {
             var doc = new XmlDocument();
             var request = (HttpWebRequest)WebRequest.Create(url + "?wsdl");
             SetWebRequest(request);
             using (var response = (HttpWebResponse)request.GetResponse())
             {
                 if (response.StatusCode != HttpStatusCode.OK)
                 {
                     var message = String.Format(CultureInfo.CurrentCulture, "Request failed. Received HTTP {0}", response.StatusCode);
                     throw new SystemException(message);
                 }
                 using (var responseStream = response.GetResponseStream())
                 {
                     if (responseStream != null)
                     {
                         using (var sr = new StreamReader(responseStream, Encoding.UTF8))
                         {
                             doc.LoadXml(sr.ReadToEnd());
                         }
                     }
                     else throw new SystemException("GetNamespace url error");
                 }
             }
             var xmlNode = doc.SelectSingleNode("//@targetNamespace");
             XmlNodeList soapActionList = doc.SelectNodes("//@soapAction");
             if (soapActionList!=null)
             {
                 for (int i = ; i < soapActionList.Count; i++)
                 {
                     var item = soapActionList.Item(i);
                     if (item != null && item.Value.EndsWith("/" + method))
                     {
                         pSoapAction = item.Value;
                     }
                 }
             }
             if (xmlNode != null)
                 return xmlNode.Value;
             throw new SystemException("GetNamespace xmlNode null");
         }

         private static byte[] EncodeParsToSoap(Dictionary<string, object> pars, String xmlNs, String methodName)
         {
             var doc = new XmlDocument();
             doc.LoadXml("<soap:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\"></soap:Envelope>");
             AddDelaration(doc);
             XmlElement soapBody = doc.CreateElement("soap", "Body", "http://schemas.xmlsoap.org/soap/envelope/");
             XmlElement soapMethod = doc.CreateElement(methodName);
             soapMethod.SetAttribute("xmlns", xmlNs);
             foreach (string k in pars.Keys)
             {
                 XmlElement soapPar = doc.CreateElement(k);
                 soapPar.InnerXml = ObjectToSoapXml(pars[k]);
                 soapMethod.AppendChild(soapPar);
             }
             soapBody.AppendChild(soapMethod);
             if (doc.DocumentElement != null) doc.DocumentElement.AppendChild(soapBody);
             return Encoding.UTF8.GetBytes(doc.OuterXml);
         }

         private static string ObjectToSoapXml(object o)
         {
             var doc = new XmlDocument();
             var mySerializer = new XmlSerializer(o.GetType());
             using (var ms = new MemoryStream())
             {
                 mySerializer.Serialize(ms, o);
                 doc.LoadXml(Encoding.UTF8.GetString(ms.ToArray(), , (int)ms.Length));
             }
             if (doc.DocumentElement != null)
             {
                 return doc.DocumentElement.InnerXml;
             }
             return o.ToString();
         }

         private static void SetWebRequest(HttpWebRequest request)
         {
             request.Credentials = CredentialCache.DefaultCredentials;
             request.Timeout = ;
         }

         private static void WriteRequestData(HttpWebRequest request, byte[] data)
         {
             request.ContentLength = data.Length;
             using (Stream writer = request.GetRequestStream())
             {
                 writer.Write(data, , data.Length);
             }
         }

         private static byte[] EncodePars(Dictionary<string, object> pars)
         {
             var sb = new StringBuilder();
             sb.Append("{");
             foreach (string k in pars.Keys)
             {
                 if (sb.Length > )
                 {
                     sb.Append(",");
                 }
                 sb.Append("\"" + k + "\"" + ":" + "\"" + pars[k] + "\"");
             }
             sb.Append("}");
             return Encoding.UTF8.GetBytes(sb.ToString());
         }

         private static String ParsToString(Dictionary<string, object> pars)
         {
             var sb = new StringBuilder();
             foreach (string k in pars.Keys)
             {
                 if (sb.Length > )
                 {
                     sb.Append("&");
                 }
                 sb.Append(k + "=" + pars[k]);
             }
             return sb.ToString();
         }

         private static XmlDocument ReadXmlResponse(WebResponse resp)
         {
             var doc = new XmlDocument();
             using (var response = (HttpWebResponse)resp)
             {
                 if (response.StatusCode != HttpStatusCode.OK)
                 {
                     var message = String.Format(CultureInfo.CurrentCulture, "Request failed. Received HTTP {0}", response.StatusCode);
                     throw new SystemException(message);
                 }
                 using (var responseStream = resp.GetResponseStream())
                 {
                     if (responseStream != null)
                         using (var sr = new StreamReader(responseStream, Encoding.UTF8))
                         {
                             doc.LoadXml(sr.ReadToEnd());
                         }
                 }
             }
             return doc;
         }

         private static string ReadTxtResponse(WebResponse resp)
         {
             using (var response = (HttpWebResponse)resp)
             {
                 var responseValue = string.Empty;
                 if (response.StatusCode != HttpStatusCode.OK)
                 {
                     var message = String.Format(CultureInfo.CurrentCulture, "Request failed. Received HTTP {0}", response.StatusCode);
                     throw new SystemException(message);
                 }
                 using (var responseStream = response.GetResponseStream())
                 {
                     if (responseStream != null)
                         using (var sr = new StreamReader(responseStream, Encoding.UTF8))
                         {
                             responseValue = sr.ReadToEnd();
                         }
                 }
                 return responseValue;
             }
         }

         private static void AddDelaration(XmlDocument doc)
         {
             XmlDeclaration decl = doc.CreateXmlDeclaration("1.0", "utf-8", null);
             doc.InsertBefore(decl, doc.DocumentElement);
         }

         private static readonly Hashtable XmlNamespaces = new Hashtable();//缓存xmlNamespace，避免重复调用GetNamespace
     }
 }