.Net网络通讯编程[利用Socket实现字串、文件、序列化对象传输]--类设计1[使用IE浏览本页]

原创 2012年03月28日 10:02:55

本案例使用.Net Socket的Tcp、Udp实现字串、文件、各种序列化对象的网络传输,同时封装了Tcp的粘包、半包处理细节,定义了网络封包格式,在发送端和接收端无需考虑内部传输细节。以下是类设计:

序列化相关类类图:

image

序列化相关类代码:

示范代码using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TcpLabCommon
{
    /// <summary>
    /// 序列化工具
    /// </summary>
    public interface ISerializeHelper
    {
        /// <summary>
        /// 序列化
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="stream"></param>
        /// <param name="item"></param>
        void Serialize<T>(System.IO.Stream stream, T item);

        /// <summary>
        /// 反序列化
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="stream"></param>
        /// <returns></returns>
        T DeSerialize<T>(System.IO.Stream stream);


    }
}
示范代码using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Runtime.Serialization.Json;

namespace TcpLabCommon
{
    /// <summary>
    /// Xml序列化
    /// </summary>
    public class XmlSerializeHelper:ISerializeHelper
    {

        public void Serialize<T>(System.IO.Stream stream, T item)
        {
            XmlSerializer serializer = new XmlSerializer(item.GetType());
            stream.Seek(0, System.IO.SeekOrigin.Begin);
            serializer.Serialize(stream, item); 
        }

        public T DeSerialize<T>(System.IO.Stream stream)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(T));
            stream.Seek(0, System.IO.SeekOrigin.Begin);
            return (T)serializer.Deserialize(stream);
        }
    }

    /// <summary>
    /// 二进制序列化
    /// </summary>
    public class BinarySerializeHelper : ISerializeHelper
    {

        public void Serialize<T>(System.IO.Stream stream, T item)
        {
            BinaryFormatter formatter = new BinaryFormatter();
            stream.Seek(0, System.IO.SeekOrigin.Begin);
            formatter.Serialize(stream, item);
        }

        public T DeSerialize<T>(System.IO.Stream stream)
        {
            BinaryFormatter formatter = new BinaryFormatter();
            stream.Seek(0, System.IO.SeekOrigin.Begin);
            return (T)formatter.Deserialize(stream);
        }
    }

    /// <summary>
    /// Soap序列化
    /// </summary>
    public class SoapSerializeHelper : ISerializeHelper
    {

        public void Serialize<T>(System.IO.Stream stream, T item)
        {
            SoapFormatter formatter = new SoapFormatter();
            stream.Seek(0, System.IO.SeekOrigin.Begin);
            formatter.Serialize(stream, item);
        }

        public T DeSerialize<T>(System.IO.Stream stream)
        {
            SoapFormatter formatter = new SoapFormatter();
            return (T)formatter.Deserialize(stream);
        }
    }

    /// <summary>
    /// Json序列化
    /// </summary>
    public class JsonSerializeHelper : ISerializeHelper
    {

        public void Serialize<T>(System.IO.Stream stream, T item)
        {
            DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(T));
            stream.Seek(0, System.IO.SeekOrigin.Begin);
            formatter.WriteObject(stream, item);
        }

        public T DeSerialize<T>(System.IO.Stream stream)
        {
            DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(T));
            stream.Seek(0, System.IO.SeekOrigin.Begin);
            return (T)formatter.ReadObject(stream);
        }
    }
}

 

网络封包相关类类图:

image

网络封包相关类代码:

示范代码using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace TcpLabCommon
{
    /// <summary>
    /// 包类型
    /// </summary>
    public enum PacketType
    {
        /// <summary>
        /// 简单字符串传输
        /// </summary>
        STRING=0,
        /// <summary>
        /// 二进制[文件传输]
        /// </summary>
        BINARY=1,
        /// <summary>
        /// 复杂对象传输[使用序列化和反序列化]
        /// </summary>
        COMPLEX=2
    }


    /// <summary>
    /// 包头
    /// </summary>
    public class NetPacketHead
    {
        /// <summary>
        /// 包头大小
        /// </summary>
        public const Int32 HEAD_SIZE = 4 * 3;

        private Int32 _version = 1;

        /// <summary>
        /// 版本
        /// </summary>
        public Int32 Version
        {
            get { return _version; }
            set { _version = value; }
        }

        private PacketType _pType = PacketType.STRING;
        /// <summary>
        /// 包类型[决定如何解包]
        /// </summary>
        public PacketType PType
        {
            get { return _pType; }
            set { _pType = value; }
        }

        private Int32 _len = 0;
        /// <summary>
        /// 包体长度[决定后面data数据的长度]
        /// </summary>
        public Int32 Len
        {
            get { return _len; }
            set { _len = value; }
        }

        
    }

    /// <summary>
    /// 网络数据包【Udp建议大小不超过548个字节,Internet标准MTU为576,减去IP数据报头(20字节)和UDP数据包头(8字节)】
    /// </summary>
    public class NetPacket
    {

        NetPacketHead _packetHead;
        /// <summary>
        /// 包头
        /// </summary>
        public NetPacketHead PacketHead
        {
            get { return _packetHead; }
            set { _packetHead = value; }
        }

        private object _data=null;
        /// <summary>
        /// 包体,根据封包类型决定包体数据类型
        /// STRING:包体为String
        /// BINARY:包体为Byte[]
        /// COMPLEX:包体为可序列化的对象
        /// </summary>
        public object Data
        {
            get { return _data; }
            set { _data = value; }
        }
    }

    /// <summary>
    /// 传输的文件
    /// </summary>
    public class NetFile
    {
        private string _fileName = string.Empty;

        public string FileName
        {
            get { return _fileName; }
            set { _fileName = value; }
        }
        private Byte[] _content;

        public Byte[] Content
        {
            get 
            {
                if (_content==null)
                    _content = new Byte[]{};
                return _content; 
            }
            set { _content = value; }
        }
    }
}

提供网络封包传输服务的核心类:

image

版权声明:本文为博主原创文章,未经博主允许不得转载。 举报

相关文章推荐

.Net网络通讯编程[利用Socket实现字串、文件、序列化对象传输]--类设计1[使用IE浏览本页]

本案例使用.Net Socket的Tcp、Udp实现字串、文件、各种序列化对象的网络传输,同时封装了Tcp的粘包、半包处理细节,定义了网络封包格式,在发送端和接收端无需考虑内部传输细节。以下是类设计:...

.Net网络通讯编程[利用Socket实现字串、文件、序列化对象传输]--使用封装的网络服务1[使用IE浏览本页]

直接使用Socket做服务器端和客户端,采用Tcp协议: 客户端代码: 示范代码using System; using System.Collections.Generic; using Sy...

精选:深入理解 Docker 内部原理及网络配置

网络绝对是任何系统的核心,对于容器而言也是如此。Docker 作为目前最火的轻量级容器技术,有很多令人称道的功能,如 Docker 的镜像管理。然而,Docker的网络一直以来都比较薄弱,所以我们有必要深入了解Docker的网络知识,以满足更高的网络需求。

.Net网络通讯编程[利用Socket实现字串、文件、序列化对象传输]--类设计2[使用IE浏览本页]

本案例使用.Net Socket的Tcp、Udp实现字串、文件、各种序列化对象的网络传输,同时封装了Tcp的粘包、半包处理细节,定义了网络封包格式,在发送端和接收端无需考虑内部传输细节。以下是类设计:...

.Net网络通讯编程[利用Socket实现字串、文件、序列化对象传输]--使用封装的网络服务2[使用IE浏览本页]

直接使用Socket做客户端,采用Udp 客户端代码: 示范代码using System; using System.Collections.Generic; using System.Lin...

.Net网络通讯编程[利用Socket实现字串、文件、序列化对象传输]--使用封装的网络服务3[聊天室][使用IE浏览本页]

本案例使用前面封装的网络服务类编写简易聊天室,采用Tcp和多线程相关技术: App.config文件: 示范代码1.0" encoding="utf-8" ?> ...

.Net网络通讯编程[利用Socket实现字串、文件、序列化对象传输]--使用封装的网络服务4[聊天室][使用IE浏览本页]

本案例使用前面封装的网络服务类编写简易聊天室,采用Tcp和异步套接字相关技术: App.config文件: 示范代码xml version="1.0" encoding="utf-8" ?...

利用socket传输对象

一、创建用户类User; package socket; import java.io.Serializable; /** * 用户类 */ public class User implemen...

利用Socket实现多客户端传输对象和传输文件实现

第一次洗博客,纯属自己纪念,主要来源是慕课网的Socket通信课程,实现课后任务多客户端传输对象,自己遇到的最大问题是忘记给User类实现序列化接口。客户端实现:package com.imooc.t...

使用Socket实现网络传输

类似的博文很多了,但是质量良莠不齐,有的可用性、可移植性比较差。这段代码我调试了两天,运行起来性能、稳定型不错。要求不高的中、小程序直接作为Dll类库引用没问题。            发篇博文用来...

使用套接字Socked实现网络通讯(网络编程)

网络编程是一门很流行,也是很基本的技术,我们一般直接使用框架来实现网络编程,很少会直接写底层的通讯代码,我们有必要知道客户端究竟是怎么样服务器进行通讯的。我们来看一个简单的实例,就是客户端请求的时候,...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)