HTTPCLINET 操作webservice

【核心代码】

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Serialization;
using System.Net;
using System.Web;
using System.IO;

using Newtonsoft.Json.Linq;

using VOL.OM.Domain.OM;
using VOL.EDI.BLL;

/// <summary>
/// Summary description for WXService
/// </summary>
public partial class WXService
{
    private static Hashtable _xmlNamespaces = new Hashtable();//缓存xmlNamespace，避免重复调用GetNamespace
    private string _url = "";

    private string _loginURL { get { return _url   "EASLogin"; } }
    private string _exeURL { get { return _url   "WSEasWebServiceHelpFacade"; } }
    private string _sessionID = "";
    private Int64 _org = -2;

    public WXService(Int64 org, string URL)
    {
        _org = org;
        _url = URL;
    }

    public void Login(string userName, string password, string slnName, string dcName, string language, int dbType)
    {
        Dictionary<string, object> param = new Dictionary<string, object>();

        param.Add("userName", userName);
        param.Add("password", password);
        param.Add("slnName", slnName);
        param.Add("dcName", dcName);
        param.Add("language", language);
        param.Add("dbType", dbType);

        XmlDocument xml = QuerySoapWebService(_loginURL, "login", param, "");

        XmlNodeList list = xml.GetElementsByTagName("sessionId");

        if (list.Count == 1)
            _sessionID = list[0].InnerText;
        else
            _sessionID = "";

        if (_sessionID.Length == 0)
            throw new HttpException(403, "登陆失败！");
    }

    private string Execute(Object data)
    {
        string val = "";
        Dictionary<string, object> param = new Dictionary<string, object>();

        string s = Newtonsoft.Json.JsonConvert.SerializeObject(data);

        param.Add("param", s);

        try
        {
            XmlDocument doc = QuerySoapWebService(_exeURL, "execute", param);

            XmlDocument doc2 = GetSOAPBody(doc);
            val = doc2.InnerText;
        }
        catch (Exception ex)
        {
            throw new Exception(string.Format("{0} 报文：[{1}]", ex.Message, s));
        }

        JObject obj = JObject.Parse(val);

        if ((int)obj["responseCode"] == 1)
        {
            val = (string)obj["resultString"];
        }
        else
        {
            throw new Exception(string.Format("{0} 报文：[{1}]", (string)obj["resultString"], s));
        }
        return val;
    }

    public void Logoff()
    {
        _sessionID = "";
    }

    //<webServices>
    //  <protocols>
    //    <add name="HttpGet"/>
    //    <add name="HttpPost"/>
    //  </protocols>
    //</webServices>

    /// <summary>
    /// 需要WebService支持Post调用
    /// </summary>
    private XmlDocument QueryPostWebService(String URL, String MethodName, Dictionary<string, object> Pars)
    {
        HttpWebRequest request = (HttpWebRequest)HttpWebRequest.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支持Get调用
    /// </summary>
    private XmlDocument QueryGetWebService(String URL, String MethodName, Dictionary<string, object> Pars)
    {
        HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(URL   "/"   MethodName   "?"   ParsToString(Pars));
        request.Method = "GET";
        request.ContentType = "application/x-www-form-urlencoded";
        SetWebRequest(request);
        return ReadXmlResponse(request.GetResponse());
    }

    /// <summary>
    /// 通用WebService调用(Soap),参数Pars为String类型的参数名、参数值
    /// </summary>
    private XmlDocument QuerySoapWebService(String URL, String MethodName, Dictionary<string, object> Pars)
    {
        if (_xmlNamespaces.ContainsKey(URL))
        {
            return QuerySoapWebService(URL, MethodName, Pars, _xmlNamespaces[URL].ToString());
        }
        else
        {
            return QuerySoapWebService(URL, MethodName, Pars, GetNamespace(URL));
        }
    }

    /// <summary>
    /// 通用WebService调用(Soap),参数Pars为String类型的参数名、参数值
    /// </summary>

    private XmlDocument QuerySoapWebService(String URL, String MethodName, Dictionary<string, object> Pars, string XmlNs)
    {
        _xmlNamespaces[URL] = XmlNs;//加入缓存，提高效率
        HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(URL);
        request.Method = "POST";
        request.ContentType = "text/xml; charset=utf-8";
        request.Headers.Add("SOAPAction", "\""   XmlNs   (XmlNs.EndsWith("/") ? "" : "/")   MethodName   "\"");
        SetWebRequest(request);
        byte[] data = EncodeParsToSoap(Pars, XmlNs, MethodName);
        WriteRequestData(request, data);
        XmlDocument doc = new XmlDocument();
        doc = ReadXmlResponse(request.GetResponse());

        return doc;
    }

    private XmlDocument GetSOAPBody(XmlDocument doc)
    {
        XmlDocument val = new XmlDocument();
        XmlNamespaceManager mgr = new XmlNamespaceManager(doc.NameTable);
        mgr.AddNamespace("soap", "http://schemas.xmlsoap.org/soap/envelope/");
        String RetXml = doc.SelectSingleNode("//soap:Body/*/*", mgr).InnerXml;
        val.LoadXml("<root>"   RetXml   "</root>");
        AddDelaration(val);
        return val;
    }

    private string GetNamespace(String URL)
    {
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(URL   "?WSDL");
        SetWebRequest(request);
        WebResponse response = request.GetResponse();
        StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(sr.ReadToEnd());
        sr.Close();
        return doc.SelectSingleNode("//@targetNamespace").Value;
    }

    private byte[] EncodeParsToSoap(Dictionary<string, object> Pars, String XmlNs, String MethodName)
    {
        XmlDocument 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);
        if (_sessionID.Length > 0)
        {
            XmlElement soapHeader = doc.CreateElement("soap", "Header", "http://schemas.xmlsoap.org/soap/envelope/");
            XmlElement session = doc.CreateElement("ns1", "SessionId", "http://login.webservice.bos.kingdee.com");
            session.InnerText = _sessionID;
            soapHeader.AppendChild(session);

            doc.DocumentElement.AppendChild(soapHeader);
        }
        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);
        doc.DocumentElement.AppendChild(soapBody);
        return Encoding.UTF8.GetBytes(doc.OuterXml);
    }
    private string ObjectToSoapXml(object o)
    {
        XmlSerializer mySerializer = new XmlSerializer(o.GetType());
        MemoryStream ms = new MemoryStream();
        mySerializer.Serialize(ms, o);
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(Encoding.UTF8.GetString(ms.ToArray()));
        if (doc.DocumentElement != null)
        {
            return doc.DocumentElement.InnerXml;
        }
        else
        {
            return o.ToString();
        }
    }
    private void SetWebRequest(HttpWebRequest request)
    {
        request.Credentials = CredentialCache.DefaultCredentials;
        request.Timeout = 100000; //请求超时前等待的毫秒数。默认值为 100,000 毫秒（100 秒）。
    }

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

    private byte[] EncodePars(Dictionary<string, object> Pars)
    {
        return Encoding.UTF8.GetBytes(ParsToString(Pars));
    }

    private String ParsToString(Dictionary<string, object> Pars)
    {
        StringBuilder sb = new StringBuilder();
        foreach (string k in Pars.Keys)
        {
            if (sb.Length > 0)
            {
                sb.Append("&");
            }
            //sb.Append(HttpUtility.UrlEncode(k)   "="   HttpUtility.UrlEncode(Pars[k].ToString()));
        }
        return sb.ToString();
    }

    private XmlDocument ReadXmlResponse(WebResponse response)
    {
        StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
        String retXml = sr.ReadToEnd();
        sr.Close();
        XmlDocument doc = new XmlDocument();
        doc.LoadXml(retXml);
        return doc;
    }

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

}