测试Remoting服务端和客户端的双向通信

最近有个项目，大致需求是，服务端发送消息通知客户端上传指定的数据，然后处理后一部分显示在服务端界面上。也是在网上胡乱搜索一片，看到一篇Remoting广播事件的博客+Remoting觉得这么还可以做。

大致原理是：通过服务端广播事件，客户端通过调用远程类将数据以参数的方式传给服务端，然后激活服务端界面层的事件就达到双向了。都是靠远程类里的2个事件，一个给服务端，一个给客户端，分别交叉执行。这就相当于： 服务端界面--远程类--客户端界面，远程类起到了一个中间人的作用样，是吧？

 

先看看服务端封装的Remoting的类

 

public   sealed   class  RemotingServer
    {
        HttpChannel tcpC;

         public   static  RemotingObject.Remoter Obj  =   null ;

         static  RemotingServer instance  =   new  RemotingServer();

         public   static  RemotingServer GetRemotingServer
        {
             get  {  return  instance; }
        }

        RemotingServer()
        {
             // tcpC = new TcpChannel(9000);
            
        }

         public   void  ServerTakeOn()
        {
             // if (!ExistServer(tcpC.ChannelName))
             // {
                RemotingConfiguration.RegisterWellKnownServiceType( typeof (RemotingObject.Remoter),  " RemotingService " , WellKnownObjectMode.Singleton);
                BinaryServerFormatterSinkProvider serverProvider  =   new  BinaryServerFormatterSinkProvider();
                BinaryClientFormatterSinkProvider clientProvider  =   new  BinaryClientFormatterSinkProvider();
                serverProvider.TypeFilterLevel  =  TypeFilterLevel.Full;
                IDictionary props  =   new  Hashtable();
                props[ " port " ]  =   9500 ;
                tcpC  =   new  HttpChannel(props, clientProvider, serverProvider);
                ChannelServices.RegisterChannel(tcpC);

                Obj  =   new  RemotingObject.Remoter();
                ObjRef objRef  =  RemotingServices.Marshal(Obj,  " RemotingMessage.soap " );
            
             // }
        }

         public   void  ServerTakeOff()
        {
             if  (ExistServer(tcpC.ChannelName))
            {
                tcpC.StopListening( null );
                ChannelServices.UnregisterChannel(tcpC);
            }
        }

         private   bool  ExistServer( string  serverName)
        {
             bool  tmp_b  =   false ;
            IChannel[] list  =  ChannelServices.RegisteredChannels;
             foreach  (IChannel ic  in  list)
            {
                HttpChannel tmp_tcp  =  (HttpChannel)ic;
                 if (tmp_tcp.ChannelName == serverName)
                {
                    tmp_b  =   true ;
                     break ;
                }
            }
             return  tmp_b;
        }
    }

 

下面2句代码特别的重要是服务端界面能和客户端共同操作的远程类

 

Obj  =   new  RemotingObject.Remoter();
ObjRef objRef  =  RemotingServices.Marshal(Obj,  " RemotingMessage.soap " );

 

接下来看看客户端的Remoting是怎么样的

 

public   sealed   class  RemotingClient
    {

        HttpChannel tcp;

        IMessage imessage  =   null ;
        EventWrapper wrapper  =   null ;

         string  _mes;

         public   string  ErrorMes
        {
             get  {  return  _mes; }
        }

         public  IMessage GetObject1
        {
             get  {  return  imessage; }
        }
         public  EventWrapper GetObject2
        {
             get  {  return  wrapper; }
        }

         static  RemotingClient _client  =   new  RemotingClient();
         public   static  RemotingClient GetObject
        {
             get  {  return  _client; }
        }
        RemotingClient()
        {
            
        }

         public   bool  Connect( string  serverIP)
        {
             try
            {

                 // _object = (RemotingObject.Remoter)Activator.GetObject(typeof(RemotingObject.Remoter),
                 //     string.Format("tcp: // {0}:9000/RemotingService", serverIP));
                
                BinaryServerFormatterSinkProvider serverProvider  =   new  BinaryServerFormatterSinkProvider();
                BinaryClientFormatterSinkProvider clientProvider  =   new  BinaryClientFormatterSinkProvider();
                serverProvider.TypeFilterLevel  =  TypeFilterLevel.Full;
                IDictionary props  =   new  Hashtable();
                props[ " port " ]  =   0 ;
                tcp  =   new  HttpChannel(props, clientProvider, serverProvider);
                ChannelServices.RegisterChannel(tcp);

                 // RemotingConfiguration.RegisterActivatedClientType(typeof(IMessage), string.Format("tcp: // {0}:9000/RemotingService", serverIP));
                imessage  =  (IMessage)Activator.GetObject( typeof (IMessage),  string .Format( " http://{0}:9500/RemotingMessage.soap " , serverIP));
                wrapper  =   new  EventWrapper();
                
                 return   true ;
            }
             catch (Exception ex)
            {
                _mes  =  ex.Message;
                 return   false ;
            }
        }

         public   void  UnConnect()
        {
             if  (ExistServer(tcp.ChannelName))
            {
                ChannelServices.UnregisterChannel(tcp);
            }
        }

         private   bool  ExistServer( string  serverName)
        {
             bool  tmp_b  =   false ;
            IChannel[] list  =  ChannelServices.RegisteredChannels;
             foreach  (IChannel ic  in  list)
            {
                HttpChannel tmp_tcp  =  (HttpChannel)ic;
                 if  (tmp_tcp.ChannelName  ==  serverName)
                {
                    tmp_b  =   true ;
                     break ;
                }
            }
             return  tmp_b;
        }
    }

 

 

是通过HTTP协议的，如果是域名的话，好像要先解析成IP吧？连接服务端，获取远程对象，给出属性返回让客户端界面能操作远程类

接下来就是客户端连接的代码，连接成功后，取出远程类，关联远程类的事件

 

        #region  连接
         private   void  btnConnect_Click( object  sender, EventArgs e)
        {
             if  ( ! client.Connect(tbxIp.Text))
            {
                MesBox.Show(client.ErrorMes,  0 );
                 return ;
            }
            imessage  =  client.GetObject1;
            wrapper  =  client.GetObject2;
             try
            {
                wrapper.SendMessageEven  +=   new  SendMessageEvenHandler(GetTxt);
                imessage.SendMessageEven  +=   new  SendMessageEvenHandler(wrapper.SendMessageing);
            }
             catch  (Exception ex)
            {
                MesBox.Show(ex.Message,  0 );
                 return ;
            }
            btnConnect.Text  =   " 已连接 " ;
            btnConnect.Enabled  =   false ;
        }
         #endregion

 

 

        #region  服务端广播
         private   void  GetTxt( string  txt)
        {
             if  (txt  ==   " A " )
            {
                 string  ip  =  GetlocalIP();
                List < string >  tmp  =  GetHardInfo();
                imessage.AddInfo(ip, tmp);
            }
        }
         #endregion

 

 

上面代码中参数TXT==A，那是我自己胡弄的一个标识，不重要，然后获取客户端的IP和硬盘信息，通过调用AddInfo方法传给服务端原程类。

在远程类中有事件处理的方法，在AddInfo方法内会调用，那么关联服务端界面的方法就会被执行，数据也通过参数传递过去了

 

public   class  Remoter : MarshalByRefObject, IMessage
    {

         #region  IMessage 成员

         public   event  SendMessageEvenHandler SendMessageEven;

         public  List < string >  HardDeskInfo  =   new  List < string > ();

         public   void  SendMessage(  string  txt)
        {
             if  (SendMessageEven  !=   null )
            {
                SendMessageEvenHandler tmp_even  =   null ;
                 foreach  (Delegate dl  in  SendMessageEven.GetInvocationList())
                {
                     try
                    {
                        tmp_even  =  (SendMessageEvenHandler)dl;
                        tmp_even(txt);
                    }
                     catch
                    {
                        SendMessageEven  -=  tmp_even;
                    }
                }
            }
        }
         public   void  AddInfo( string  IP, List < string >  hardinfo)
        {
             string  tmp  =   string .Empty;
             foreach  ( string  s  in  hardinfo)
            {
                 // 获取剩余大小
                 string  tmp1  =  s.Substring(s.LastIndexOf( " @ " )  +   1 );
                 // 获取分区@总大小
                 string  tmp2  =  s.Substring( 0 , s.Length  -  tmp1.Length  -   1 );
                 // 获取总大小
                 string  tmp3  =  tmp2.Substring(tmp2.LastIndexOf( " @ " )  +   1 );
                 // 获取分区
                 string  tmp4  =  tmp2.Substring( 0 , tmp2.Length  -  tmp3.Length  -   1 );
                 // 格式是 IP@分区@总大小@剩余大小
                tmp  =   string .Format( " {0}@{1}@{2}@{3} " , IP, tmp4, tmp3, tmp1);
                HardDeskInfo.Add(tmp);
                ClientReciveData(tmp);
            }
        }
         public   void  ClearInfo()
        {
            HardDeskInfo.Clear();
        }
         public   override   object  InitializeLifetimeService()
        {
             return   null ;
        }
         #endregion

         #region  激活服务端事件
         public   delegate   void  ClientReciveDataEvenHandler( string  txt);
         public   event  ClientReciveDataEvenHandler ClientReciveDataEven;
         public   void  ClientReciveData( string  txt)
        {
             if  (ClientReciveDataEven  !=   null )
            {
                ClientReciveDataEvenHandler tmp_even  =   null ;
                 foreach  (Delegate dl  in  ClientReciveDataEven.GetInvocationList())
                {
                     try
                    {
                        tmp_even  =  (ClientReciveDataEvenHandler)dl;
                        tmp_even(txt);
                    }
                     catch
                    {
                        ClientReciveDataEven  -=  tmp_even;
                    }
                }
            }
        }
         #endregion

    }

 

 

上面这个就是原创类了，是继承于接口IMessage

 

namespace  RemotingObject.Common
{
     public   delegate   void  SendMessageEvenHandler( string  txtt);

     public   interface  IMessage
    {
         event  SendMessageEvenHandler SendMessageEven;
         void  SendMessage( string  txt);
         void  AddInfo( string  IP, List < string >  hardinfo);
    }
}

 

 

接口和远程类是不同的类库生成的DLL，在服务端2个都会被调用，但是客户端只会调用接口的DLL，中间还有一个事件适配器吧？是这么叫的吧？这个方式源于Remoting服务端事件广播

 

namespace  RemotingObject.Common
{
     public   class  EventWrapper : MarshalByRefObject
    {
         public   event  SendMessageEvenHandler SendMessageEven;

         public   void  SendMessageing(  string  txt)
        {
            SendMessageEven(txt);
        }

         public   override   object  InitializeLifetimeService()
        {
             return   null ;
        }
    }
}

 

 

这2个的关系我到现在还没搞懂的，不过能使用它们就很不错啦

最后看看服务端界面方法关联的远程类事件

 

        #region  窗体加载
         private   void  frmMain_Load( object  sender, EventArgs e)
        {
            _server  =  RemotingServer.GetRemotingServer;
            _server.ServerTakeOn();
            RemotingServer.Obj.ClientReciveDataEven  +=   new  RemotingObject.Remoter.ClientReciveDataEvenHandler(ClientReciveData);
        }
         #endregion

         #region  窗体关闭
         private   void  frmMain_FormClosing( object  sender, FormClosingEventArgs e)
        {
            RemotingServer.Obj.ClientReciveDataEven  -=   new  RemotingObject.Remoter.ClientReciveDataEvenHandler(ClientReciveData);
            _server.ServerTakeOff();
        }
         #endregion

         #region  远程类事件
         private   void  ClientReciveData( string  txt)
        {
            SetLst(txt);
        }
         #endregion
        #region  设置列表
         private   void  SetLst( string  tmp)
        {
             string  ip  =   string .Empty;
             string  dir  =   string .Empty;
             string  all  =   string .Empty;
             string  free  =   string .Empty;
             // 剩余大小
             string  tmp1  =  tmp.Substring(tmp.LastIndexOf( " @ " )  +   1 );
             // IP@分区@总大小
             string  tmp2  =  tmp.Substring( 0 , tmp.Length  -  tmp1.Length  -   1 );
             // 总大小
             string  tmp3  =  tmp2.Substring(tmp2.LastIndexOf( " @ " )  +   1 );
             // IP@分区
             string  tmp4  =  tmp2.Substring( 0 , tmp2.Length  -  tmp3.Length  -   1 );
             // 分区
             string  tmp5  =  tmp4.Substring(tmp4.LastIndexOf( " @ " )  +   1 );
             // IP
             string  tmp6  =  tmp4.Substring( 0 , tmp4.Length  -  tmp5.Length  -   1 );

            ip  =  tmp6;
            dir  =  tmp5;
            all  =  tmp3;
            free  =  tmp1;

            ListViewItem itm  =   new  ListViewItem();
            itm.SubItems[ 0 ].Text  =  ip;
            itm.SubItems.Add(dir);
            itm.SubItems.Add(all);
            itm.SubItems.Add(free);

            lst.Items.Add(itm);
        }

 

接受到参数传递的数据，处理下放到ListView显示出来，不过我记得Remoting远程类所激活的事件都应该是子线程的吧？怎么我这没报错（子线程不能操作主线程的控件）呢？

整个工程大概就是这样的，希望上面的思路不是很乱吧？