动态调用WebService及使用

1、写一个webService（添加一个web服务）
在当前的网站上 右击-添加-新建项-web服务

然后在生成的类中添加调用的方法，如这里在WebService测试.asmx中添加一个test方法

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Web;
 5 using System.Web.Services;
 6  
 7 namespace WebApplication1
 8 {
 9     /// <summary>
10     /// WebService测试 的摘要说明
11     /// </summary>
12     [WebService(Namespace = "http://tempuri.org/")]
13     [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
14     [System.ComponentModel.ToolboxItem(false)]
15     // 若要允许使用 ASP.NET AJAX 从脚本中调用此 Web 服务，请取消注释以下行。 
16     // [System.Web.Script.Services.ScriptService]
17     public class WebService测试 : System.Web.Services.WebService
18     {
19  
20         [WebMethod]
21         public string HelloWorld()
22         {
23             return "Hello World";
24         }
25         [WebMethod]
26         public int test(int a,int b)
27         {
28             return a + b;
29         }
30     }
31 }

可以允许该webService测试，在浏览器中输入webService地址

如：http://localhost:46391/WebService测试.asmx

可看到两个方法，一个是HelloWorld，另一个是刚才新建的test方法。

 

 

点击test可以进行测试

 

 

2、调用webService（添加服务引用）

在web项目中 右击-添加服务引用

再 地址栏 中输入webService地址，如上面的webService应输入http://localhost:46391/WebService测试.asmx

然后点转到，可搜索出对应的webService服务。

 

然后，再需要创建一个serviceClient，来调用webService方法（这里用winform程序简单写个按钮点击调用）

 

 

private void button1_Click(object sender, EventArgs e)
         {
            ServiceReference2.WebService测试SoapClient service = new ServiceReference2.WebService测试SoapClient();
            int sum = service.test(1, 12);
            MessageBox.Show(sum.ToString());
         }

 

3动态调用webservice

 

封装一个WebServiceHelpel类，方便调用

 

 1 public class WebServiceHelper
 2     {
 3         /// <summary>
 4         /// 调用WebService
 5         /// </summary>
 6         /// <param name="wsUrl">WebService地址</param>
 7         /// <param name="methodName">方法名称</param>
 8         /// <param name="args">参数列表</param>
 9         /// <returns></returns>
10         public static object InvokeWebService(string wsUrl, string methodName, params object[] args)
11         {
12             return InvokeWebService(wsUrl, null, methodName, args);
13         }
14         /// <summary>
15         /// 调用WebService
16         /// </summary>
17         /// <param name="wsUrl">WebService地址</param>
18         /// <param name="className">类名</param>
19         /// <param name="methodName">方法名称</param>
20         /// <param name="args">参数列表</param>
21         /// <returns></returns>
22         public static object InvokeWebService(string wsUrl, string className, string methodName, params object[] args)
23         {
24             string @namespace = "EnterpriseServerBase.WebService.DynamicWebCalling";//ServiceBase.WebService.DynamicWebLoad或EnterpriseServerBase.WebService.DynamicWebCalling
25             if (string.IsNullOrEmpty(className))
26             {
27                 className = GetWsClassName(wsUrl);
28             }
29             try
30             {
31                 //获取WSDL
32                 WebClient wc = new WebClient();
33                 Stream stream = wc.OpenRead(wsUrl + "?WSDL");
34                 ServiceDescription sd = ServiceDescription.Read(stream);
35                 ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
36                 sdi.AddServiceDescription(sd, "", "");
37                 CodeNamespace cn = new CodeNamespace(@namespace);
38                 //生成客户端代理类代码
39                 CodeCompileUnit ccu = new CodeCompileUnit();
40                 ccu.Namespaces.Add(cn);
41                 sdi.Import(cn, ccu);
42                 CSharpCodeProvider csc = new CSharpCodeProvider();
43                 ICodeCompiler icc = csc.CreateCompiler();
44                 //设定编译参数
45                 CompilerParameters cplist = new CompilerParameters();
46                 cplist.GenerateExecutable = false;
47                 cplist.GenerateInMemory = true;
48                 cplist.ReferencedAssemblies.Add("System.dll");
49                 cplist.ReferencedAssemblies.Add("System.XML.dll");
50                 cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
51                 cplist.ReferencedAssemblies.Add("System.Data.dll");
52                 //编译代理类
53                 CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu);
54                 if (true == cr.Errors.HasErrors)
55                 {
56                     System.Text.StringBuilder sb = new System.Text.StringBuilder();
57                     foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
58                     {
59                         sb.Append(ce.ToString());
60                         sb.Append(System.Environment.NewLine);
61                     }
62                     throw new Exception(sb.ToString());
63                 }
64                 //生成代理实例，并调用方法
65                 System.Reflection.Assembly assembly = cr.CompiledAssembly;
66                 Type t = assembly.GetType(@namespace + "." + className, true, true);
67                 object obj = Activator.CreateInstance(t);
68                 System.Reflection.MethodInfo mi = t.GetMethod(methodName);
69                 return mi.Invoke(obj, args);
70             }
71             catch (Exception ex)
72             {
73                 throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
74             }
75         }
76         private static string GetWsClassName(string wsUrl)
77         {
78             string[] parts = wsUrl.Split('/');
79             string[] pps = parts[parts.Length - 1].Split('.');
80             return pps[0];
81         }
82     }

 

动态调用

static void Main(string[] args)
        {
            object o = WebServiceHelper.InvokeWebService("http://localhost:46391/WebService测试.asmx", "test",11,2);
            Console.WriteLine(o.ToString());//结果输出13
            Console.ReadKey();
        }

 

以上方法基于Visual Studio编译器来实现，如果已知第三方已有的一个WebService接口，该如何用通用的方式去调用？

HTTP请求方式调用webService

浏览器打开WebService的测试页面后，可以看到下面有SOAP协议的报文请求格式（可以理解成发送的是XML格式的HTTP请求）

如下面的webservice

 

 只需要给HTTP请求拼装和上述信息一样的请求接口即可访问，demo如下

 1 //构造soap请求信息
 2             StringBuilder soap = new StringBuilder();
 3 
 4             string strJson = "xxxxxx";
 7             soap.Append("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
 8             soap.Append("<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/\">");
 9             soap.Append("<soap:Header>");
10                 soap.Append("<UserSoapHeader xmlns=\"http://www.xjjrj.com/\">");
11                   soap.Append("<SerializeId>string</SerializeId>");
12                   soap.Append("<UserName>string</UserName>");
13                   soap.Append("<FunUrl>/FeeManagePlugin/F_Q_VERIF_IN/Save_F_Q_VERIF_IN.do</FunUrl>");
14                   soap.Append("<Timestamp>string</Timestamp>");
15                   soap.Append("<Md5>string</Md5>");
16                 soap.Append("</UserSoapHeader>");
17              soap.Append("</soap:Header>");
18               soap.Append("<soap:Body>");
19                 soap.Append("<WebServiceDispatch xmlns=\"http://www.xjjrj.com/\">");
20                   soap.Append("<strRequestJSON>"+ strJson + "</strRequestJSON>");
21                 soap.Append("</WebServiceDispatch>");
22               soap.Append("</soap:Body>");
23             soap.Append("</soap:Envelope>");
24             string url = "http://192.168.0.123:8081/WebService/WebServiceInterface.asmx";
25             string r = HttpHelper.HttpPost(url, soap.ToString(), "text/xml; charset=utf-8");
26 
27 public static class HttpHelper
28     {
29         public static string HttpPost(string url, string strJson,string contentType = "application/json")//post同步请求方法
30         {
31             string responseStr = string.Empty;
32             try
33             {
34                 WebRequest request = WebRequest.Create(url);
35                 request.Method = "Post";
36                 request.ContentType = contentType;
37 
38                 byte[] requestData = System.Text.Encoding.UTF8.GetBytes(strJson);
39                 request.ContentLength = requestData.Length;
40 
41                 Stream newStream = request.GetRequestStream();
42                 newStream.Write(requestData, 0, requestData.Length);
43                 newStream.Close();
44 
45                 var response = request.GetResponse();
46                 Stream ReceiveStream = response.GetResponseStream();
47                 using (StreamReader stream = new StreamReader(ReceiveStream, Encoding.UTF8))
48                 {
49                     responseStr = stream.ReadToEnd();
50                 }
51 
52                 return responseStr;
53             }
54             catch (Exception e)
55             {
56                 throw e;
57             }
58             
59         }
60     }

 

 

C#反射 动态调用webService带SoapHeader 

  1 /// <summary>
  2     /// Web Service服务类
  3     /// </summary>
  4     public class WSHelper
  5     {
  6         /// < summary> 
  7         /// 动态调用web服务 （不含有SoapHeader）
  8         /// < /summary> 
  9         /// < param name="url">WSDL服务地址< /param> 
 10         /// < param name="methodname">方法名< /param> 
 11         /// < param name="args">参数< /param> 
 12         /// < returns>< /returns> 
 13         public static object InvokeWebServiceNoSoapHeader(string url, string methodname, params object[] args)
 14         {
 15             return WSHelper.InvokeWebService(url, null, methodname, null, args);
 16         }
 17         /// <summary>
 18         /// 动态调用web服务（含有SoapHeader）
 19         /// </summary>
 20         /// <param name="url"></param>
 21         /// <param name="methodname"></param>
 22         /// <param name="soapHeader"></param>
 23         /// <param name="args"></param>
 24         /// <returns></returns>
 25         public static object InvokeWebServiceSoapHeader(string url,string className, string methodname, SoapHeader soapHeader, params object[] args)
 26         {
 27 
 28             return WSHelper.InvokeWebService(url, className, methodname, soapHeader, args);
 29         }
 30         /// < summary> 
 31         /// 动态调用web服务 
 32         /// < /summary> 
 33         /// < param name="url">WSDL服务地址< /param> 
 34         /// < param name="classname">类名< /param> 
 35         /// < param name="methodname">方法名< /param> 
 36         /// < param name="args">参数< /param> 
 37         /// < returns>< /returns> 
 38         public static object InvokeWebService(string url, string classname, string methodname, SoapHeader soapHeader, params object[] args)
 39         {
 40             string @namespace = "EnterpriseServerBase.WebService.DynamicWebCalling";
 41             if ((classname == null) || (classname == ""))
 42             {
 43                 classname = WSHelper.GetWsClassName(url);
 44             }
 45             try
 46             {
 47                 //获取WSDL 
 48                 WebClient wc = new WebClient();
 49                 Stream stream = wc.OpenRead(url + "?WSDL");
 50                 ServiceDescription sd = ServiceDescription.Read(stream);
 51                 ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
 52                 sdi.AddServiceDescription(sd, "", "");
 53                 CodeNamespace cn = new CodeNamespace(@namespace);
 54 
 55                 //生成客户端代理类代码 
 56                 CodeCompileUnit ccu = new CodeCompileUnit();
 57                 ccu.Namespaces.Add(cn);
 58                 sdi.Import(cn, ccu);
 59                 CSharpCodeProvider icc = new CSharpCodeProvider();
 60 
 61                 //设定编译参数 
 62                 CompilerParameters cplist = new CompilerParameters();
 63                 cplist.GenerateExecutable = false;
 64                 cplist.GenerateInMemory = true;
 65                 cplist.ReferencedAssemblies.Add("System.dll");
 66                 cplist.ReferencedAssemblies.Add("System.XML.dll");
 67                 cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
 68                 cplist.ReferencedAssemblies.Add("System.Data.dll");
 69 
 70                 //编译代理类 
 71                 CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu);
 72                 if (cr.Errors.HasErrors)
 73                 {
 74                     System.Text.StringBuilder sb = new System.Text.StringBuilder();
 75                     foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
 76                     {
 77                         sb.Append(ce.ToString());
 78                         sb.Append(System.Environment.NewLine);
 79                     }
 80                     throw new Exception(sb.ToString());
 81                 }
 82 
 83                 //保存生产的代理类，默认是保存在bin目录下面  
 84                 //TextWriter writer = File.CreateText("MyWebServices.cs");
 85                 //icc.GenerateCodeFromCompileUnit(ccu, writer, null);
 86                 //writer.Flush();
 87                 //writer.Close();
 88 
 89                 //生成代理实例 
 90                 System.Reflection.Assembly assembly = cr.CompiledAssembly;
 91                 Type t = assembly.GetType(@namespace + "." + classname, true, true);
 92                 object obj = Activator.CreateInstance(t);
 93 
 94                 #region 设置SoapHeader
 95                 FieldInfo client = null;
 96                 object clientkey = null;
 97                 if (soapHeader != null)
 98                 {
 99                     client = t.GetField(soapHeader.ClassName + "Value");
100                     //获取客户端验证对象    soap类  
101                     Type typeClient = assembly.GetType(@namespace + "." + soapHeader.ClassName);
102                     //为验证对象赋值  soap实例    
103                     clientkey = Activator.CreateInstance(typeClient);
104                     //遍历属性  
105                     foreach (KeyValuePair<string, object> property in soapHeader.Properties)
106                     {
107                         typeClient.GetField(property.Key).SetValue(clientkey, property.Value);
108                         // typeClient.GetProperty(property.Key).SetValue(clientkey, property.Value, null);  
109                     }
110                 }
111                 #endregion
112 
113                 if (soapHeader != null)
114                 {
115                     //设置Soap头  
116                     client.SetValue(obj, clientkey);
117                     //pro.SetValue(obj, soapHeader, null);  
118                 }
119 
120                 //调用指定的方法
121                 System.Reflection.MethodInfo mi = t.GetMethod(methodname);
122                 //方法名错误（找不到方法），给出提示
123                 if (null == mi)
124                 {
125                     return "方法名不存在，请检查方法名是否正确！";
126                 }
127                 return mi.Invoke(obj, args);
128                 // PropertyInfo propertyInfo = type.GetProperty(propertyname); 
129                 //return propertyInfo.GetValue(obj, null); 
130             }
131             catch (Exception ex)
132             {
133                 throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
134             }
135         }
136         private static string GetWsClassName(string wsUrl)
137         {
138             string[] parts = wsUrl.Split('/');
139             string[] pps = parts[parts.Length - 1].Split('.');
140             return pps[0];
141         }
142 
143         /// <summary>  
144         /// 构建SOAP头，用于SoapHeader验证  
145         /// </summary>  
146         public class SoapHeader
147         {
148             /// <summary>  
149             /// 构造一个SOAP头  
150             /// </summary>  
151             public SoapHeader()
152             {
153                 this.Properties = new Dictionary<string, object>();
154             }
155             /// <summary>  
156             /// 构造一个SOAP头  
157             /// </summary>  
158             /// <param name="className">SOAP头的类名</param>  
159             public SoapHeader(string className)
160             {
161                 this.ClassName = className;
162                 this.Properties = new Dictionary<string, object>();
163             }
164             /// <summary>  
165             /// 构造一个SOAP头  
166             /// </summary>  
167             /// <param name="className">SOAP头的类名</param>  
168             /// <param name="properties">SOAP头的类属性名及属性值</param>  
169             public SoapHeader(string className, Dictionary<string, object> properties)
170             {
171                 this.ClassName = className;
172                 this.Properties = properties;
173             }
174             /// <summary>  
175             /// SOAP头的类名  
176             /// </summary>  
177             public string ClassName { get; set; }
178             /// <summary>  
179             /// SOAP头的类属性名及属性值  
180             /// </summary>  
181             public Dictionary<string, object> Properties { get; set; }
182             /// <summary>  
183             /// 为SOAP头增加一个属性及值  
184             /// </summary>  
185             /// <param name="name">SOAP头的类属性名</param>  
186             /// <param name="value">SOAP头的类属性值</param>  
187             public void AddProperty(string name, object value)
188             {
189                 if (this.Properties == null)
190                 {
191                     this.Properties = new Dictionary<string, object>();
192                 }
193                 Properties.Add(name, value);
194             }
195         }
196     }

 参考：https://www.cnblogs.com/xibei666/p/4635859.html

posted @ 2017-07-19 01:07  酒香逢  阅读(745)  评论(0)  编辑  收藏  举报