总结WebService的一些封装技巧

今天早上起来，想谈谈.NET中的WebService，当然我不想讲什么是WebService，或者怎么用WebService，因为那个大家随便Google一下前100页都能找到答案。今天我想来分享一下我在用WebService中的一些技巧（至少我认为是技巧，还有点成就感），希望能给大家以后在用WebService时一点帮助和启发吧。

一、问题诞生 -- 大部分解决方案的背后总是一些头痛的问题

很早以前就用过传说中的WebService，但一直是用常规的思路在用：创建WebService项目-->写Web服务方法--> 在项目中添加Web引用-->调用Web方法。这样貌似很好，非常符合规范，在一段时间内效果也还可以，但渐渐的随着项目的扩大和同时参与项目的人员增多，就越来越觉得这种常规的方法很是不爽，为什么呢？我每次修改WebService端（添加、删除Web方法，以及修改方法名称），在引用端我都要更新WebService引用，其实是就是更新WSDL文件，很是烦人。

二、化分为合 -- 传说分久必合，合久必分

好吧，既然增加、删除、修改web方法名都会引起WSDL的更新，那么我们索性用一个统一的方法来作为webservice的访问入口吧，然后内部用switch case来区分调用哪个方法，先贴代码吧，再来简单讲讲：

统一访问接口IRemoteCall：

 
 
 
      
  
  
  1. public interface IRemoteCall{      
    2.   
  
  
  2. byte[] GeneralCall(string methodName, params byte[] param);} 
    3.

然后定义一个WebService并实现以上接口（以前还没真在webservice上实现过接口，哈哈）：

 
 
 
      
  
  
  1. [WebService(Namespace = http://tempuri.org/)]
    2.   
  
  
  2. [WebServiceBinding(ConformsTo =   WsiProfiles.BasicProfile1_1)]
    3.   
  
  
  3. [ToolboxItem(false)]public class BlogService : 
    4.   
  
  
  4. System.Web.Services.WebService, IRemoteCall{      
    5.   
  
  
  5. [WebMethod(EnableSession = true)]     
    6.   
  
  
  6.  public byte[] GeneralCall(string methodName, params byte[] param) 
    7.   
  
  
  7.    {          
    8.   
  
  
  8. switch (methodName)         
    9.   
  
  
  9.  {            
    10.   
  
  
  10.   case "LoadBlog":            
    11.   
  
  
  11.      {                 
    12.   
  
  
  12.     long blogId = Serializer.DeserializeToObject(param);                   
    13.   
  
  
  13.   BLLBlogArtical ba = new AppBlog().LoadBlog(blogId);                 
    14.   
  
  
  14.     return Serializer.SerializeToBinary(ba);            
    15.   
  
  
  15.      }           
    16.   
  
  
  16.    case "DeleteBlog":          
    17.   
  
  
  17.        {                
    18.   
  
  
  18.      //To Do Your Code        
    19.   
  
  
  19.              return null;          
    20.   
  
  
  20.        }    
    21.   
  
  
  21.        }     }} 
    22.

这里为什么要定义接口IRemoteCall呢，主要是为接下来统一调用webservice服务的，所有实现这个接口的webservice类都可以通过GeneralCall来完成调用，待会将webservice访问器的时候会具体讲到，这里主要讲讲这个switch case。

这里我们定义了一个统一的访问入口

 
 
 
      
  
  
  1. byte[] GeneralCall(string methodName,params byte[] param) 
    2.

意思是：传入要调用的方法名称以及序列化后的参数，返回序列化后的结果。这里为了统一数据，我们均对参数和返回值都序列化成byte数组，即用Serializer.SerializeToBinary(object)来实现，这样所有调用就都统一了格式。

有人可能会提出质疑，这样方法名称都已字符串形式是不是会显得难看，而且字符串容易出错，还没有智能提示？那也好解决，我们可以把方法名称定义成const常量就可以了。这里我对webservice的一个态度是：webservice层就是完成转接和调度工作的，它仅仅起到承接的作用，用了他可以将服务任意分布，所以里面是没有任何逻辑的（逻辑都是被封装在其他dll中的），最多是一些数据转换，所以我采用了这种模糊接口的方式。

三、自定义webservice访问器

上面我们完成了webservice端的工作，接下来就来实现客户端对webservice的灵活调用，这里上面定义的那个IRemoteCall就起到作用了，首先我们定义一个webservice访问器类RemoteCaller，代码如下：

 
 
 
      
  
  
  1. using System;using   
    2.   
  
  
  2. System.Collections.Generic;using   
    3.   
  
  
  3. System.Text;using   
    4.   
  
  
  4. System.Collections;using System.Web.Services.Protocols;  
    5.   
  
  
  5. using SharedLib_403;   
    6.   
  
  
  6. namespace ITIvy.Shared.RemoteCaller{      
    7.   
  
  
  7.      ///      
    8.   
  
  
  8.  /// 远程接口访问器     
    9.   
  
  
  9.  ///      
    10.   
  
  
  10.  public class RemoteCaller    
    11.   
  
  
  11.   {      
    12.   
  
  
  12.     private string _MethodName;     
    13.   
  
  
  13.      private byte[] _ParamByte;      
    14.   
  
  
  14.     private IRemoteCall _Caller;       
    15.   
  
  
  15.    private ArrayList _Params;       
    16.   
  
  
  16.     ///          
    17.   
  
  
  17.  /// 参数列表     
    18.   
  
  
  18.      ///         
    19.   
  
  
  19.   public ArrayList Params      
    20.   
  
  
  20.     {           
    21.   
  
  
  21.    get { return _Params; }            
    22.   
  
  
  22.   set { _Params = value; }      
    23.   
  
  
  23.     }  
    24.   
  
  
  24.          ///        
    25.   
  
  
  25.    /// 序列化后的参数        
    26.   
  
  
  26.   ///        
    27.   
  
  
  27.    public byte[] ParamByte       
    28.   
  
  
  28.    {        
    29.   
  
  
  29.       get { return _ParamByte; }      
    30.   
  
  
  30.         set { _ParamByte = value; }       
    31.   
  
  
  31.    }         ///       
    32.   
  
  
  32.     /// 远程服务方法名称        
    33.   
  
  
  33.   ///         
    34.   
  
  
  34.   public string MethodName    
    35.   
  
  
  35.       {        
    36.   
  
  
  36.       get { return _MethodName; }        
    37.   
  
  
  37.       set { _MethodName = value; }       
    38.   
  
  
  38.    }         ///       
    39.   
  
  
  39.     /// 远程服务调用接口       
    40.   
  
  
  40.    ///        
    41.   
  
  
  41.    public IRemoteCall Caller    
    42.   
  
  
  42.       {          
    43.   
  
  
  43.     get { return _Caller; }      
    44.   
  
  
  44.         set { _Caller = value; }    
    45.   
  
  
  45.       }          
    46.   
  
  
  46.  ///        
    47.   
  
  
  47.    /// 构造       
    48.   
  
  
  48.    ///       
    49.   
  
  
  49.     /// Webservice远程接口        
    50.   
  
  
  50.   public RemoteCaller(IRemoteCall caller)        {             
    51.   
  
  
  51.  _Caller = caller;            
    52.   
  
  
  52.   _Params = new ArrayList();      
    53.   
  
  
  53.     }       
    54.   
  
  
  54.     ///       
    55.   
  
  
  55.     /// 调用远程接口        ///       
    56.   
  
  
  56.     /// 方法名称        
    57.   
  
  
  57.   /// 参数对象     
    58.   
  
  
  58.      ///       
    59.   
  
  
  59.     public byte[] Call(string methodName, object param)   
    60.   
  
  
  60.      {           
    61.   
  
  
  61.    try            {         
    62.   
  
  
  62.          _MethodName = methodName;            
    63.   
  
  
  63.     _ParamByte = Serializer.SerializeToBinary(param);         
    64.   
  
  
  64.          return _Caller.GeneralCall(_MethodName, _ParamByte);          
    65.   
  
  
  65.     }     
    66.   
  
  
  66.          catch (Exception ex)       
    67.   
  
  
  67.      {                
    68.   
  
  
  68.   if (ex is SoapException)                
    69.   
  
  
  69. throw new Exception(((SoapException)ex).Detail["Message"].InnerText); 
    70.   
  
  
  70.                else                   
    71.   
  
  
  71.    throw ex;          
    72.   
  
  
  72.     }        }        
    73.   
  
  
  73.    ///       
    74.   
  
  
  74.     /// 调用远程接口       
    75.   
  
  
  75.    ///         
    76.   
  
  
  76.   /// 方法名称        
    77.   
  
  
  77.   /// 参数列表       
    78.   
  
  
  78.    ///          
    79.   
  
  
  79.  public byte[] Call(string methodName, ArrayList param)       
    80.   
  
  
  80.    {            
    81.   
  
  
  81.   try            
    82.   
  
  
  82.   {        
    83.   
  
  
  83.           _MethodName = methodName;                
    84.   
  
  
  84. _Params = param;       
    85.   
  
  
  85.            _ParamByte = Serializer.SerializeToBinary(_Params);           
    86.   
  
  
  86.        return _Caller.GeneralCall(_MethodName, _ParamByte);         
    87.   
  
  
  87.      }          
    88.   
  
  
  88.     catch (Exception ex)        
    89.   
  
  
  89.       {                
    90.   
  
  
  90.   if (ex is SoapException)                 
    91.   
  
  
  91.  throw new Exception(((SoapException)ex).Detail["Message"].InnerText);           
    92.   
  
  
  92.        else               
    93.   
  
  
  93.        throw ex;            }   
    94.   
  
  
  94.        }         
    95.   
  
  
  95.   ///       
    96.   
  
  
  96.     /// 调用远程接口      
    97.   
  
  
  97.     ///         
    98.   
  
  
  98.   /// 方法名称       
    99.   
  
  
  99.    /// 参数对象数组        
    100.   
  
  
  100.   ///       
    101.   
  
  
  101.     public byte[] Call(string methodName, params object[] param)   
    102.   
  
  
  102.        {         
    103.   
  
  
  103.      try          
    104.   
  
  
  104.     {        
    105.   
  
  
  105.           foreach (object obj in param)         
    106.   
  
  
  106.              _Params.Add(obj);              
    107.   
  
  
  107.   _MethodName = methodName;       
    108.   
  
  
  108.            _ParamByte = Serializer.SerializeToBinary(_Params);               
    109.   
  
  
  109.    return _Caller.GeneralCall(_MethodName, _ParamByte);           
    110.   
  
  
  110.    }       
    111.   
  
  
  111.        catch (Exception ex)           
    112.   
  
  
  112.    {                
    113.   
  
  
  113.   if (ex is SoapException)                 
    114.   
  
  
  114.      throw new Exception(((SoapException)ex).Detail["Message"].InnerText);    
    115.   
  
  
  115.             else                   
    116.   
  
  
  116.    throw ex;            }    
    117.   
  
  
  117.       }           
    118.   
  
  
  118. ///       
    119.   
  
  
  119.     /// 调用远程接口     
    120.   
  
  
  120.      ///      
    121.   
  
  
  121.      ///      
    122.   
  
  
  122.      public byte[] Call()       
    123.   
  
  
  123.    {            try          
    124.   
  
  
  124.     {             
    125.   
  
  
  125.      if (string.IsNullOrEmpty(_MethodName))                 
    126.   
  
  
  126.      throw new Exception("远程方法不能为空！");                
    127.   
  
  
  127.   return _Caller.GeneralCall(_MethodName, _ParamByte);            }    
    128.   
  
  
  128.           catch (Exception ex)      
    129.   
  
  
  129.         {                
    130.   
  
  
  130.   if (ex is SoapException)          
    131.   
  
  
  131.             throw new Exception(((SoapException)ex).Detail["Message"].InnerText);  
    132.   
  
  
  132.               else                 
    133.   
  
  
  133.      throw ex;         
    134.   
  
  
  134.      }        }         
    135.   
  
  
  135.   ///          
    136.   
  
  
  136.  /// 调用远程接口        ///    
    137.   
  
  
  137.        /// 返回值类型       
    138.   
  
  
  138.  ///         
    139.   
  
  
  139. public T Call()     
    140.   
  
  
  140.      {            byte[] resultByte = Call();          
    141.   
  
  
  141.   return Serializer.DeserializeToObject(resultByte);        }     
    142.   
  
  
  142.       ///        
    143.   
  
  
  143.    /// 调用远程接口        
    144.   
  
  
  144.   ///        
    145.   
  
  
  145.    /// 返回值类型      
    146.   
  
  
  146.     /// 方法名称       
    147.   
  
  
  147.    /// 参数列表      
    148.   
  
  
  148.     ///       
    149.   
  
  
  149.     public T Call(string methodName, ArrayList param)   
    150.   
  
  
  150.        {            
    151.   
  
  
  151.   byte[] resultByte = Call(methodName, param);            
    152.   
  
  
  152.   return Serializer.DeserializeToObject(resultByte);        
    153.   
  
  
  153.   }     
    154.   
  
  
  154.       public T Call(string methodName, object param)        {          
    155.   
  
  
  155.     try            {            
    156.   
  
  
  156.       _MethodName = methodName;              
    157.   
  
  
  157.     _ParamByte = Serializer.SerializeToBinary(param);                
    158.   
  
  
  158.   byte[] resultByte = _Caller.GeneralCall(_MethodName, _ParamByte);          
    159.   
  
  
  159.    
    160.   
  
  
  160.        return Serializer.DeserializeToObject(resultByte);          
    161.   
  
  
  161.     }            catch (Exception ex)           
    162.   
  
  
  162.    {        
    163.   
  
  
  163.           if (ex is SoapException)             
    164.   
  
  
  164.        throw new Exception(((SoapException)ex).Detail["Message"].InnerText);    
    165.   
  
  
  165.             else                  
    166.   
  
  
  166.     throw ex;          
    167.   
  
  
  167.     }        }         
    168.   
  
  
  168.   ///      
    169.   
  
  
  169.      /// 调用远程接口      
    170.   
  
  
  170.     ///    
    171.   
  
  
  171.        /// 返回值类型     
    172.   
  
  
  172.      /// 方法名称        
    173.   
  
  
  173.   /// 参数对象数组     
    174.   
  
  
  174.      ///         
    175.   
  
  
  175.   public T Call(string methodName, params object[] param)        
    176.   
  
  
  176.   {          
    177.   
  
  
  177.     byte[] resultByte = Call(methodName, param);           
    178.   
  
  
  178.    return Serializer.DeserializeToObject(resultByte);       
    179.   
  
  
  179.    }    }}  
    180.   
  
  
  180.  
    181.

这个访问器主要是定义了一系列访问接口的重载，利用了c#的泛型更加使接口简单了。哈哈，这个类就能让我们实现一句话调用webservice，相当简洁。注意里面的IRemoteCall属性，就是只要传入实现了该接口的类，就都可以通过该访问器来访问webservice。如何使用该类呢，下面给一个例子吧：

IRemoteCall Caller = new BlogService.BlogService();BLLBlogArtical bllArtical = new RemoteCaller(Caller).Call("LoadBlog", id);

抱歉，说错了，要两句话来调用，但是这里少去了很多数据转换的工作，因为有了泛型，呵呵，而且我可以在RemoteCaller这个访问器类中做很多工作，比如异常处理，权限验证等等。

四、总结 -- 写了这么多不总结可不行

这个实现方法的核心在于用IRemoteCall接口来规范webservice类的实现方式均为统一GenerateCall，然后 webservice类中通过switch case来将所有方法整合在一起，避免频繁更新WSDL的麻烦，***客户端利用IRemoteCall定义一个webservice访问器类 RemoteCaller来提供统一的webservice访问。

新闻名称：总结WebService的一些封装技巧
文章来源：http://www.hantingmc.com/qtweb/news7/368557.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

软件开发知识

各行业网站

App开发　　 　成都免费建站　　 　温江服务器托管　　 　交互设计　　 　成都名片印刷厂　　 　响应式网站　　 　关键词优化　　 　绵竹网站建设　　 　域名申请　　 　成都网站建设公司　　 　响应式网站建设　　 　网站报价方案　　 　双流做网站　　 　成都网站维护公司　　 　成都网络营销　　 　品牌官网设计　　 　手机网站制作　　 　芦山网站建设　　 　成都网站维护公司　　 　腾讯香港虚拟主机