如何通过序列化在网络间传递对象，网络协议:轻松定义自己的网络通讯协议

//每次编写设计网络通讯程序时，总面对一个问题，就是要自定义一组应用协议（即通讯协议），然后再写相应的方法来解析协议，并提供相应的接口供上层调用。假如只是简单的文本信息通讯还轻易，但要交换一些控制信息或结构复杂的数据时，比如做联机游戏，更是让人头疼。
　　
// 最近忽然想到一个点子，可以用对象串行化技术将对象直接转换为二进制数据发送，然后接收时直接还原为对象。具体过程是，将要发送的数据放在一个HashTable中，串行化后发送出去，在接收方接收到数据并还原为HashTable，根据预先约定好的Key和获取自己关心的数据。在这种情况下，定义通讯协议的内容实质上也就只是指定一组Key就行了。再也不用做那些规定第几个字段是什么类型有多长的烦躁的事情了。
　　
// 可能很多人很善于用XML，也将之广泛用于网络通讯。XML有不可比拟的好处，因为它是同平台无关的，而且基本上任何开发语言都有现成库来解析XML。这个和我的观点并不冲突。对象串行化并不局限于二进制数据。C#里有丰富的方法，可以将对象串行化为XML文档，也支持用SOAP协议来串行化数据。所以只要用公共的串行化标准来串行化对象，也可以达到跨平台、跨语言的目的。其实现在流行的Web Service其核心技术也就大概是这样吧。
　　
// 原理说完了，贴段代码做个例子。ObjectTransferClient（简称OTC）是一个利用UDP协议及二进制对象串行化的包括对象发送和接收的库。调用方法很简单，用Send发送对象，响应ReceiveObject事件来处理接收的对象。至于具体细节就不多叙述了，相信有一定C#基础的人能轻松看懂的。
　　
// 这一原理的应用潜力是巨大的，我在这里抛砖引玉，还请指教。
　　
using System;
　　using System.Net.Sockets;
　　using System.Net;
　　using System.Runtime.Serialization.Formatters.Binary;
　　using System.Threading;
namespace OTC
{
    /// <summary>
    /// 对象传送器，使用UDP协议通过网路在不同主机间传送对象。
    /// </summary>
    public class ObjectTransferClient : IDisposable
    {
        private Thread ListenThread;
        private BinaryFormatter Serializer = new BinaryFormatter();
        private int m_Port;
        private UdpClient m_Client;
        private bool m_IsStart;
        private bool m_IsConnected;

/// <summary>
        /// 接收到对象事件
        /// </summary>
        public event ReceiveObjectEventHandler ReceiveObject;

/// <summary>
        /// 构建一个对象传送器，默认端口7321
        /// </summary>
        public ObjectTransferClient()
            : this(7321)
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }

/// <summary>
        /// 指定端口号构建一个对象传送器。
        /// </summary>
        /// <param name="port">端口号</param>
        public ObjectTransferClient(int port)
        {
            this.m_Port = port;
            this.m_IsConnected = false;
            this.m_IsStart = false;
        }

/// <summary>
        /// 初始化传送器并开始工作
        /// </summary>
        public void Start()
        {
            if (!this.m_IsStart)
            {
                this.m_Client = new UdpClient(this.m_Port);
                ListenThread = new Thread(new ThreadStart(this.Listen));
                ListenThread.Start();
                this.m_IsStart = true;
            }
        }

/// <summary>
        /// 使用指定的主机名和端口连接默认的远程主机
        /// </summary>
        /// <param name="hostname">主机名</param>
        /// <param name="port">端口</param>
        public void Connect(string hostname, int port)
        {
            this.m_Client.Connect(hostname, port);
        }

/// <summary>
        /// 使用指定的IP地址和端口连接默认的远程主机
        /// </summary>
        /// <param name="ipaddress">IP地址</param>
        /// <param name="port">端口</param>
        public void Connect(IPAddress ipaddress, int port)
        {
            this.m_Client.Connect(ipaddress, port);
        }

/// <summary>
        /// 使用网络终结点连接默认的远程主机
        /// </summary>
        /// <param name="iep">网络端点</param>
        public void Connect(IPEndPoint iep)
        {
            this.m_Client.Connect(iep);
        }

private byte[] CreateArgPackage(object obj)
{
IPEndPoint local = new IPEndPoint(IPAddress.Any, this.m_Port);//提供一个 IP 地址，指示服务器应侦听所有网络接口上的客户端活动。此字段为只读。 Any 字段等效于以点分隔的四部分表示法格式的 0.0.0.0。

System.IO.MemoryStream outStream = new System.IO.MemoryStream();
            this.Serializer.Serialize(outStream, new ReceiveObjectEventArgs(obj, local));//要传过去的对象和本地IP
            return outStream.ToArray();
        }

/// <summary>
        /// 将对象发送到默认主机。调用此方法前必须先调用Connect方法连接默认主机。
        /// </summary>
        /// <param name="obj">要发送的对象</param>
        public void Send(object obj)
        {
            if (this.IsConnected)
            {
                byte[] data = this.CreateArgPackage(obj);
                this.m_Client.Send(data, data.Length);
            }
            else
            {
                throw new Exception("必须先连接默认主机");
            }
        }

/// <summary>
        /// 将对象发送到指定的主机。若调用了Connect方法连接了默认主机，则此方法不可用。
        /// </summary>
        /// <param name="obj">要发送的对象</param>
        /// <param name="remoteIEP">目标主机的网络端点</param>
        public void Send(object obj, IPEndPoint remoteIEP)
        {
            if (this.IsConnected)
            {
                throw new Exception("已经连接了默认主机");
            }
            else
            {
                byte[] data = this.CreateArgPackage(obj);
                this.m_Client.Send(data, data.Length, remoteIEP);
            }
        }

/// <summary>
        /// 监听接收数据线程方法
        /// </summary>
        protected void Listen()
        {
            BinaryFormatter Serializer = new BinaryFormatter();
            IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
            while (true)
            {
                try
                {
                    object revobj = Serializer.Deserialize(new System.IO.MemoryStream(m_Client.Receive(ref RemoteIpEndPoint)));
                    ReceiveObjectEventArgs revarg = (ReceiveObjectEventArgs)revobj;//
                    RemoteIpEndPoint.Port = revarg.RemoteIEP.Port;
                    revarg.RemoteIEP = RemoteIpEndPoint;
                    if (this.ReceiveObject != null)//判断事件是否发生
                    {
                        this.ReceiveObject(this, revarg);//触发事件函数，但程序中未绑定事件函数
                    }
                }
                catch
                {
                    break;
                }
            }
        }

#region 公共属性区

/// <summary>
        /// 返回或设置接收对象的端口号
        /// </summary>
        public int Port
        {
            get
            {
                return this.m_Port;
            }
            set
            {
                this.m_Port = value;
            }
        }

/// <summary>
        /// 返回对象发送器是否已经初始化并开始工作
        /// </summary>
        public bool IsStart
        {
            get
            {
                return this.m_IsStart;
            }
        }

/// <summary>
        /// 返回对象发送器是否已经连接默认远程主机
        /// </summary>
        public bool IsConnected
        {
            get
            {
                return this.m_IsConnected;
            }
        }

#endregion

#region IDisposable 成员

public void Dispose()
        {
            // TODO:　添加 ObjectTransferClient.Dispose 实现
            this.m_Client.Close();
            this.ListenThread.Abort();
        }
        #endregion
    }

/// <summary>
    /// 接收对象事件参数
    /// </summary>

    [Serializable]
    public class ReceiveObjectEventArgs : EventArgs
    {
        private object _obj;
        private System.Net.IPEndPoint _iep;

/// <summary>
        /// 构建一个接收对象事件的参数
        /// </summary>
        /// <param name="obj">接收到的对象</param>
        /// <param name="iep">发送者的网络端点</param>
        internal ReceiveObjectEventArgs(object obj, System.Net.IPEndPoint iep)
        {
            this._obj = obj;
            this._iep = iep;
        }

/// <summary>
        /// 构建一个空的接收对象事件参数
        /// </summary>
        public ReceiveObjectEventArgs()
            : this(null, null)
        {
        }

/// <summary>
        /// 接收到的对象
        /// </summary>
        public object Obj
        {
            get
            {
                return this._obj;
            }
        }
        /// <summary>
        /// 发送方的网络端点
        /// </summary>
        public System.Net.IPEndPoint RemoteIEP
        {
            get
            {
                return this._iep;
            }
            set
            {
                this._iep = value;
            }
        }
    }

/// <summary>
    /// 接收对象事件的委托
    /// </summary>
    public delegate void ReceiveObjectEventHandler(object sender, ReceiveObjectEventArgs e);
}

/// <summary>
        /// 接收到对象事件
        /// </summary>
        public event ReceiveObjectEventHandler ReceiveObject;

private byte[] CreateArgPackage(object obj)
        {
            IPEndPoint local = new IPEndPoint(IPAddress.Any, this.m_Port);
            System.IO.MemoryStream outStream = new System.IO.MemoryStream();
            this.Serializer.Serialize(outStream, new ReceiveObjectEventArgs(obj, local));
            return outStream.ToArray();
        }

/// <summary>
        /// 监听接收数据线程方法
        /// </summary>
        protected void Listen()
        {
            BinaryFormatter Serializer = new BinaryFormatter();
            IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
            while (true)
            {
                try
                {
                    object revobj = Serializer.Deserialize(new System.IO.MemoryStream(m_Client.Receive(ref RemoteIpEndPoint)));
                    ReceiveObjectEventArgs revarg = (ReceiveObjectEventArgs)revobj;
                    RemoteIpEndPoint.Port = revarg.RemoteIEP.Port;
                    revarg.RemoteIEP = RemoteIpEndPoint;
                    if (this.ReceiveObject != null)//判断事件是否发生
                    {
                        this.ReceiveObject(this, revarg);//触发事件函数
                    }
                }
                catch
                {
                    break;
                }
            }
        }

#region 公共属性区

#endregion

#region IDisposable 成员

/// <summary>
        /// 构建一个空的接收对象事件参数
        /// </summary>
        public ReceiveObjectEventArgs()
            : this(null, null)
        {
        }

/// <summary>
    /// 接收对象事件的委托
    /// </summary>
    public delegate void ReceiveObjectEventHandler(object sender, ReceiveObjectEventArgs e);
}

/// <summary>
        /// 接收到对象事件
        /// </summary>
        public event ReceiveObjectEventHandler ReceiveObject;

/// <summary>
        /// 监听接收数据线程方法
        /// </summary>
        protected void Listen()
        {
            BinaryFormatter Serializer = new BinaryFormatter();
            IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
            while (true)
            {
                try
                {
                    object revobj = Serializer.Deserialize(new System.IO.MemoryStream(m_Client.Receive(ref RemoteIpEndPoint)));
                    ReceiveObjectEventArgs revarg = (ReceiveObjectEventArgs)revobj;
                    RemoteIpEndPoint.Port = revarg.RemoteIEP.Port;
                    revarg.RemoteIEP = RemoteIpEndPoint;
                    if (this.ReceiveObject != null)
                    {
                        this.ReceiveObject(this, revarg);
                    }
                }
                catch
                {
                    break;
                }
            }
        }

#region 公共属性区

#endregion

#region IDisposable 成员

/// <summary>
        /// 构建一个空的接收对象事件参数
        /// </summary>
        public ReceiveObjectEventArgs()
            : this(null, null)
        {
        }

/// <summary>
    /// 接收对象事件的委托
    /// </summary>
    public delegate void ReceiveObjectEventHandler(object sender, ReceiveObjectEventArgs e);
}

/// <summary>
        /// 接收到对象事件
        /// </summary>
        public event ReceiveObjectEventHandler ReceiveObject;

/// <summary>
        /// 监听接收数据线程方法
        /// </summary>
        protected void Listen()
        {
            BinaryFormatter Serializer = new BinaryFormatter();
            IPEndPoint RemoteIpEndPoint = new IPEndPoint(IPAddress.Any, 0);
            while (true)
            {
                try
                {
                    object revobj = Serializer.Deserialize(new System.IO.MemoryStream(m_Client.Receive(ref RemoteIpEndPoint)));
                    ReceiveObjectEventArgs revarg = (ReceiveObjectEventArgs)revobj;
                    RemoteIpEndPoint.Port = revarg.RemoteIEP.Port;
                    revarg.RemoteIEP = RemoteIpEndPoint;
                    if (this.ReceiveObject != null)
                    {
                        this.ReceiveObject(this, revarg);
                    }
                }
                catch
                {
                    break;
                }
            }
        }

#region 公共属性区

#endregion

#region IDisposable 成员

/// <summary>
    /// 接收对象事件参数
    /// </summary>
    [Serializable]
    public class ReceiveObjectEventArgs : EventArgs
    {
        private object _obj;
        private System.Net.IPEndPoint _iep;

/// <summary>
        /// 构建一个空的接收对象事件参数
        /// </summary>
        public ReceiveObjectEventArgs()
            : this(null, null)
        {
        }

/// <summary>
    /// 接收对象事件的委托
    /// </summary>
    public delegate void ReceiveObjectEventHandler(object sender, ReceiveObjectEventArgs e);
}

如何通过序列化在网络间传递对象，网络协议:轻松定义自己的网络通讯协议相关推荐

Binder相关面试总结（五）：为什么Activity间传递对象需要序列化
前言我们都知道进行Android 开发的时候,跳转到Activity和Fragment的时候,传递对象是通过Intent或者bundle 进行传递.当这个对象没有实现序列化的时候当你通过Inetn ...
android bundle 对象,Android Bundle传递对象
首先Android的Bundle是可以传递对象的.我们可以用Bundle b = new Bundle():b.putSerializable("key", 对象引用); 但是这样 ...
java intent bundle_Android 通过Intent使用Bundle传递对象详细介绍
Android 通过Intent使用Bundle传递对象 Android开发中有时需要在应用中或进程间传递对象,下面详细介绍Intent使用Bundle传递对象的方法. 被传递的对象需要先实现序列化, ...
java byte序列化,java对象序列化byte[] and byte[]反序列化对象--转
import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOExceptio ...
IBinder对象在进程间传递的形式(二)
这篇文章是对IBinder对象在进程间传递的形式(一)这篇文章的补充,首先还是把service启动过程的流程图贴上来 Android中主要通过2种方法来获得service IBinder: 1. ...
IBinder对象在进程间传递的形式(一)
命题当service经常被远程调用时,我们常常用到aidl来定一个接口供service和client来使用,这个其实就是使用Binder机制的IPC通信.当client bind service成功 ...
微信小程序页面间传递数组对象
在微信小程序中,有时候使用wx.navigateTo()跳转页面时要传递过长的参数或者传递一个数组对象会发现传递不过去情景再现: 发送端接收端输出值我们可以使用以下方法解决: 在发送端对数据进 ...
微信小程序页面间的对象传递
例子: 页面架构: page A→a.js B→b.js a.js→b.js, 此时a.js想传递studentBean这个对象到b.js接收, 常规的传递如下: var studentJson = ...
设计数据层组件并在层间传递数据
Angela Crocker.Andy Olsen 和 Edward Jezierski Microsoft Corporation 2002年8月适用于: Microsoft® .NET ...

如何通过序列化在网络间传递对象，网络协议:轻松定义自己的网络通讯协议

如何通过序列化在网络间传递对象，网络协议:轻松定义自己的网络通讯协议相关推荐

最新文章

热门文章