yunxizfj

等待...

导航

测试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远程类所激活的事件都应该是子线程的吧?怎么我这没报错(子线程不能操作主线程的控件)呢?

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

posted on 2010-03-17 17:25  yunxizfj  阅读(2676)  评论(0编辑  收藏  举报