介绍开源的.net通信框架NetworkComms框架 源码分析（六）SendReceiveOptions

原文网址： http://www.cnblogs.com/csdev

Networkcomms 是一款C# 语言编写的TCP/UDP通信框架  作者是英国人  以前是收费的 目前作者已经开源  许可是:Apache License v2

开源地址是:https://github.com/MarcFletcher/NetworkComms.Net

发送接收参数

networkcomms默认时，使用protobuf序列化器，使用别的序列化器的话，就需要设定SendReceiveOptions参数了.

如果要启用加密的话，也需要设定SendReceiveOptions参数

using System;
using System.Collections.Generic;
using System.Text;
using NetworkCommsDotNet.DPSBase;
using NetworkCommsDotNet.Tools;
using System.Threading;

namespace NetworkCommsDotNet
{
    /// <summary>
    /// Contains options and flags for sending and receiving data such as serialisation method, data processors, encryption etc.
    /// Several static constructors are provided to help create SendReceiveOptions in the most common formats.
    /// 收发参数类
    /// 包含  用于发送和接收数据时相关的参数设定    包括 序列化方法 数据处理器 加密方法等
    /// 系统提供了几个静态构造器来帮助创建SendReceiveOptions
    /// </summary>
    public class SendReceiveOptions
    {
        /// <summary>
        /// If true any packets sent with this <see cref="SendReceiveOptions"/> will be forced to trigger a receive confirmation.
        /// 如果设定为True,对方服务器在接收消息后，会发一个确认消息回来
        /// </summary>
        public bool ReceiveConfirmationRequired
        {
            get { return Options.ContainsKey("ReceiveConfirmationRequired"); }
            set {
                if (value) Options["ReceiveConfirmationRequired"] = "";
                else Options.Remove("ReceiveConfirmationRequired");
            }
        }

        /// <summary>
        /// If true any packets sent with this <see cref="SendReceiveOptions"/> will include the packet creation time in the header.
        /// 如果设定为True,相关数据包的包头中会包含数据包的创建时间
        /// </summary>
        public bool IncludePacketConstructionTime
        {
            get { return Options.ContainsKey("IncludePacketConstructionTime"); }
            set
            {
                if (value) Options["IncludePacketConstructionTime"] = "";
                else Options.Remove("IncludePacketConstructionTime");
            }
        }

        /// <summary>
        /// If true any packets sent with this <see cref="SendReceiveOptions"/> will be nested which can be used to obscure the actual
        /// packet type.
        /// 嵌套的数据类型
        /// 如果设置为True,数据包在发送时将会进行嵌套以便于掩盖实际的数据包类型
        /// </summary>
        public bool UseNestedPacket
        {
            get { return Options.ContainsKey("UseNestedPacketType"); }
            set
            {
                if (value) Options["UseNestedPacketType"] = "";
                else Options.Remove("UseNestedPacketType");
            }
        }

        /// <summary>
        ///  Incoming packets are handled using a flexible QueueItemPriority (Default - QueueItemPriority.Normal). Reserved internal
        ///  packet types and packets marked with QueueItemPriority.Highest are not enqueued but handled in real time by the thread
        ///  handling the incoming data. You are free to specify the queue item priority for packet handlers using this
        ///  SendReceiveOptions by setting this value as desired. CAUTION: Only use QueueItemPriority.Highest sparingly.
        ///  使用灵活的 “队列项目优先级” 以便处理数据  默认优先级为  QueueItemPriority.Normal
        ///  保留的内部数据类型（比如心跳检测，消息确认等）使用的优先级别较高  为QueueItemPriority.Highest  即最高优先级 不进入队列等待 而是有当前
        ///  线程直接处理 您可以通过设置此项属性随意的制定数据包的“队列项目优先级”
        ///  警告 应该有节制的使用QueueItemPriority.Highest 即最高优先级
        /// </summary>
        public QueueItemPriority ReceiveHandlePriority
        {
            get
            {
                if (Options.ContainsKey("ReceiveHandlePriority"))
                    return (QueueItemPriority)Enum.Parse(typeof(QueueItemPriority), Options["ReceiveHandlePriority"]);
                else
                    return QueueItemPriority.Normal;
            }
            set
            {
                Options["ReceiveHandlePriority"] = Enum.GetName(typeof(QueueItemPriority), value);
            }
        }

        private DataSerializer _dataSerializer;
        private List<DataProcessor> _dataProcessors;

        /// <summary>
        /// Gets the <see cref="DPSBase.DataSerializer"/> that should be used when sending information
        /// 获取数据序列化器  比如 protobuf.net
        /// </summary>
        public DataSerializer DataSerializer
        {
            get { return _dataSerializer; }
            protected set
            {
                if (value == null)
                    _dataSerializer = DPSManager.GetDataSerializer<NullSerializer>();
                else
                    _dataSerializer = value;
            }
        }

        /// <summary>
        /// Gets the <see cref="DPSBase.DataProcessor"/>s that should be used when sending information. <see cref="DPSBase.DataProcessor"/>s are applied in index order
        /// 获取数据处理器 比如 加密 压缩
        /// </summary>
        public List<DataProcessor> DataProcessors
        {
            get { return _dataProcessors; }
            protected set
            {
                if (value == null)
                {
                    _dataProcessors = new List<DataProcessor>();
                    return;
                }

                )
                    throw new ArgumentException("Only 7 data Processors are supported");

                //validate the list to make sure all the data processors are the same
                //验证处理器列表 以防止处理器重复
                List<DataProcessor> distinctProcessors = new List<DataProcessor>();
                foreach (var processor in value)
                {
                    if(distinctProcessors.Contains(processor))
                        throw new ArgumentException("Same data processor cannot be applied twice");

                    distinctProcessors.Add(processor);
                }

                _dataProcessors = value;
            }
        }

        private Dictionary<string, string> options;

        /// <summary>
        /// Gets the options that should be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s on object serialization and deserialization
        /// 这些参数值给 数据序列化器和  数据处理器 在序列化的过程中使用
        /// </summary>
        public Dictionary<string, string> Options
        {
            get { return options; }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class with a specified <see cref="DPSBase.DataSerializer"/>, set of <see cref="DPSBase.DataProcessor"/>s and and other options
        /// 初始化一个新的实例   并制定相应的序列化器 数据处理器  和其他参数
        /// </summary>
        /// <param name="serializer">数据序列化器   The <see cref="DPSBase.DataSerializer"/> to use</param>
        /// <param name="dataProcessors">数据处理器   The set of <see cref="DPSBase.DataProcessor"/>s to use.  The order in the list determines the order the <see cref="DPSBase.DataProcessor"/>s will be applied</param>
        /// <param name="options">其他参数   Allows additional options to be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s</param>
        public SendReceiveOptions(DataSerializer serializer, List<DataProcessor> dataProcessors, Dictionary<string, string> options)
        {
            if (serializer == null)
                throw new ArgumentNullException("serializer", "The serializer argument when creating a sendReceiveOptions object should never be null.");

            this.DataSerializer = serializer;
            this.DataProcessors = dataProcessors;

            if (options != null)
                this.options = options;
            else
                this.options = new Dictionary<string, string>();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class providing only options for the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s.  This constructor should only be used when adding packet handlers for incoming connections
       ///初始化一个新的实例
       ///此构造函数只在为进入的连接添加数据包处理器时使用
        /// </summary>
        /// <param name="options">参数选项  这些参数将被传给给序列化器和处理器使用 Allows additional options to be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s</param>
        public SendReceiveOptions(Dictionary<string, string> options)
        {
            DataSerializer = null; //This will set the NullSerialiser as a default  把序列化器设置为空
            DataProcessors = null; //This will set an empty options dictionary      把处理器设置为空

            if (options != null)
                this.options = options;
            else
                this.options = new Dictionary<string, string>();
        }

        /// <summary>
        /// Initializes an empty instance of the <see cref="SendReceiveOptions"/> class.
        /// 初始化一个空的实例
        /// </summary>
        public SendReceiveOptions()
        {
            DataSerializer = null; //This will set the NullSerialiser as a default
            DataProcessors = null; //This will set an empty options dictionary
            this.options = new Dictionary<string, string>();
        }

        /// <summary>
        /// Determines whether the supplied <see cref="SendReceiveOptions"/> is compatible, from a serialization point of view, with this instance
        /// 比较参数中的SendReceiveOptions对象是否与当前对象一致
        /// </summary>
        /// <param name="options">要比较的对象  The <see cref="SendReceiveOptions"/> to compare against</param>
        /// <returns>如果一致  返回True   True if the options are compatible, false otherwise</returns>
        /// <remarks>如果2个对象使用相同的序列化器和处理器 则为一致  否则为不一致  Two <see cref="SendReceiveOptions"/> instances will be compatible if they use the same <see cref="DPSBase.DataSerializer"/> and the same set of <see cref="DPSBase.DataProcessor"/>s</remarks>
        public bool OptionsCompatible(SendReceiveOptions options)
        {
            if (options == null) throw new ArgumentNullException("options", "Provided SendReceiveOptions cannot be null.");

            bool equal = options.DataSerializer == DataSerializer;

            ; i < options.DataProcessors.Count; i++)
                equal &= options.DataProcessors[i] == DataProcessors[i];

            return equal;
        }

        /// <summary>
        /// Create a deep clone of this <see cref="SendReceiveOptions"/> object.
        /// 创建对象的深拷贝
        /// </summary>
        /// <returns>The cloned object</returns>
        public object Clone()
        {
            return new SendReceiveOptions(DataSerializer, new List<DataProcessor>(DataProcessors), new Dictionary<string,string>(Options));
        }
    }

    /// <inheritdoc />
    /// <typeparam name="T_DS">T_DS 类型为序列化器 The type of <see cref="DPSBase.DataSerializer"/> to use</typeparam>
    public class SendReceiveOptions<T_DS> : SendReceiveOptions
        where T_DS : DataSerializer
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class. The <see cref="DPSBase.DataSerializer"/> is passed as a generic parameter and no <see cref="DPSBase.DataProcessor"/>s are used. To provide additional options see other overrides.
        /// 初始化一个新的SendReceiveOption类实例  序列化器作为泛型参数使用
        /// </summary>
        public SendReceiveOptions()
            : base(null)
        {
            DataSerializer = DPSManager.GetDataSerializer<T_DS>();
            DataProcessors = null; //Note that this will cause data processors to be set to an empty list  设置数据处理器为空 即不对数据进行加密压缩等处理

            if (DataSerializer == null)
                throw new InvalidOperationException("Attempted to use null DataSerializer. If this exception is thrown DPSManager.GetDataSerializer<DS>() has failed.");
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class. The <see cref="DPSBase.DataSerializer"/> is passed as a generic parameter and no <see cref="DPSBase.DataProcessor"/>s are used.
        /// Further options can be passed to the <see cref="DPSBase.DataSerializer"/> as an argument which may be null
        /// 初始化一个新的SendReceiveOption类实例  序列化器作为泛型参数传递
        /// 相关的选项（可以为空）可以作为参数传递给序列化器和处理器
        /// </summary>
        /// <param name="options">Additional options to be passed to the <see cref="DPSBase.DataSerializer"/></param>
        public SendReceiveOptions(Dictionary<string, string> options)
            : base(options)
        {
            DataSerializer = DPSManager.GetDataSerializer<T_DS>();
            DataProcessors = null; //Note that this will cause data processors to be set to an empty list 设置数据处理器为空 即不对数据进行加密压缩等处理

            if (DataSerializer == null)
                throw new InvalidOperationException("Attempted to use null DataSerializer. If this exception is thrown DPSManager.GetDataSerializer<DS>() has failed.");
        }
    }

    /// <inheritdoc />
    /// <typeparam name="T_DS">The type of <see cref="DPSBase.DataSerializer"/> to use</typeparam>
    /// <typeparam name="T_DP1">The type of <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    public class SendReceiveOptions<T_DS, T_DP1> : SendReceiveOptions
        where T_DS : DataSerializer
        where T_DP1 : DataProcessor
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class. The <see cref="DPSBase.DataSerializer"/> and a single <see cref="DPSBase.DataProcessor"/> while will be used are passed as generic parameters. To provide additional options see other overrides.
        ///初始化一个新的SendReceiveOptions实例   数据序列化器和一个数据处理器作为泛型参数传递
        /// </summary>
        public SendReceiveOptions()
            : base(null)
        {
            DataSerializer = DPSManager.GetDataSerializer<T_DS>();
            DataProcessors = new List<DataProcessor>() { DPSManager.GetDataProcessor<T_DP1>() };

            if (DataSerializer == null)
                throw new InvalidOperationException("Attempted to use null DataSerializer. If this exception is thrown DPSManager.GetDataSerializer<DS>() has failed.");
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class. The <see cref="DPSBase.DataSerializer"/> and a single <see cref="DPSBase.DataProcessor"/> while will be used are passed as generic parameters
        /// Further options can be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/> as an argument which may be null
        /// 初始化一个新的SendReceiveOptions实例   数据序列化器和一个数据处理器作为泛型参数传递
        /// 相关的选项（可以为空）可以作为参数传递给序列化器和处理器
        /// </summary>
        /// <param name="options">Additional options to be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/></param>
        public SendReceiveOptions(Dictionary<string, string> options)
            : base(options)
        {
            DataSerializer = DPSManager.GetDataSerializer<T_DS>();
            DataProcessors = new List<DataProcessor>() { DPSManager.GetDataProcessor<T_DP1>() };

            if (DataSerializer == null)
                throw new InvalidOperationException("Attempted to use null DataSerializer. If this exception is thrown DPSManager.GetDataSerializer<DS>() has failed.");
        }
    }

    /// <inheritdoc />
    /// <typeparam name="T_DS">The type of <see cref="DPSBase.DataSerializer"/> to use</typeparam>
    /// <typeparam name="T_DP1">The type of the first <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP2">The type of the second <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    public class SendReceiveOptions<T_DS, T_DP1, T_DP2> : SendReceiveOptions
        where T_DS : DataSerializer
        where T_DP1 : DataProcessor
        where T_DP2 : DataProcessor
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class. The <see cref="DPSBase.DataSerializer"/> and 2 <see cref="DPSBase.DataProcessor"/>s while will be used are passed as generic parameters
        /// Further options can be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s as an argument which may be null
        /// 初始化一个新的SendReceiveOptions实例   数据序列化器和二个数据处理器作为泛型参数传递
        /// 相关的选项（可以为空）可以作为参数传递给序列化器和处理器
        /// </summary>
        /// <param name="options">Additional options to be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s</param>
        public SendReceiveOptions(Dictionary<string, string> options)
            : base(options)
        {
            DataSerializer = DPSManager.GetDataSerializer<T_DS>();
            DataProcessors = new List<DataProcessor>() {
                DPSManager.GetDataProcessor<T_DP1>(),
                DPSManager.GetDataProcessor<T_DP2>() };

            if (DataSerializer == null)
                throw new InvalidOperationException("Attempted to use null DataSerializer. If this exception is thrown DPSManager.GetDataSerializer<DS>() has failed.");
        }
    }

    /// <inheritdoc />
    /// <typeparam name="T_DS">The type of <see cref="DPSBase.DataSerializer"/> to use</typeparam>
    /// <typeparam name="T_DP1">The type of the first <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP2">The type of the second <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP3">The type of the third <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    public class SendReceiveOptions<T_DS, T_DP1, T_DP2, T_DP3> : SendReceiveOptions
        where T_DS : DataSerializer
        where T_DP1 : DataProcessor
        where T_DP2 : DataProcessor
        where T_DP3 : DataProcessor
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class. The <see cref="DPSBase.DataSerializer"/> and 3 <see cref="DPSBase.DataProcessor"/>s while will be used are passed as generic parameters
        /// Further options can be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s as an argument which may be null
        /// 初始化一个新的SendReceiveOptions实例   数据序列化器和三个数据处理器作为泛型参数传递
        /// 相关的选项（可以为空）可以作为参数传递给序列化器和处理器
        /// </summary>
        /// <param name="options">Additional options to be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s</param>
        public SendReceiveOptions(Dictionary<string, string> options)
            : base(options)
        {
            DataSerializer = DPSManager.GetDataSerializer<T_DS>();
            DataProcessors = new List<DataProcessor>() {
                DPSManager.GetDataProcessor<T_DP1>(),
                DPSManager.GetDataProcessor<T_DP2>(),
                DPSManager.GetDataProcessor<T_DP3>() };

            if (DataSerializer == null)
                throw new InvalidOperationException("Attempted to use null DataSerializer. If this exception is thrown DPSManager.GetDataSerializer<DS>() has failed.");
        }
    }

    /// <inheritdoc />
    /// <typeparam name="T_DS">The type of <see cref="DPSBase.DataSerializer"/> to use</typeparam>
    /// <typeparam name="T_DP1">The type of the first <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP2">The type of the second <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP3">The type of the third <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP4">The type of the fourth <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    public class SendReceiveOptions<T_DS, T_DP1, T_DP2, T_DP3, T_DP4> : SendReceiveOptions
        where T_DS : DataSerializer
        where T_DP1 : DataProcessor
        where T_DP2 : DataProcessor
        where T_DP3 : DataProcessor
        where T_DP4 : DataProcessor
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class. The <see cref="DPSBase.DataSerializer"/> and 4 <see cref="DPSBase.DataProcessor"/>s while will be used are passed as generic parameters
        /// Further options can be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s as an argument which may be null
        /// 初始化一个新的SendReceiveOptions实例   数据序列化器和四个数据处理器作为泛型参数传递
        /// 相关的选项（可以为空）可以作为参数传递给序列化器和处理器
        /// </summary>
        /// <param name="options">Additional options to be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s</param>
        public SendReceiveOptions(Dictionary<string, string> options)
            : base(options)
        {
            DataSerializer = DPSManager.GetDataSerializer<T_DS>();
            DataProcessors = new List<DataProcessor>() {
                DPSManager.GetDataProcessor<T_DP1>(),
                DPSManager.GetDataProcessor<T_DP2>(),
                DPSManager.GetDataProcessor<T_DP3>(),
                DPSManager.GetDataProcessor<T_DP4>() };

            if (DataSerializer == null)
                throw new InvalidOperationException("Attempted to use null DataSerializer. If this exception is thrown DPSManager.GetDataSerializer<DS>() has failed.");
        }
    }

    /// <inheritdoc />
    /// <typeparam name="T_DS">The type of <see cref="DPSBase.DataSerializer"/> to use</typeparam>
    /// <typeparam name="T_DP1">The type of the first <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP2">The type of the second <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP3">The type of the third <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP4">The type of the fourth <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP5">The type of the fifth <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    public class SendReceiveOptions<T_DS, T_DP1, T_DP2, T_DP3, T_DP4, T_DP5> : SendReceiveOptions
        where T_DS : DataSerializer
        where T_DP1 : DataProcessor
        where T_DP2 : DataProcessor
        where T_DP3 : DataProcessor
        where T_DP4 : DataProcessor
        where T_DP5 : DataProcessor
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class. The <see cref="DPSBase.DataSerializer"/> and 5 <see cref="DPSBase.DataProcessor"/>s while will be used are passed as generic parameters
        /// Further options can be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s as an argument which may be null
        /// 初始化一个新的SendReceiveOptions实例   数据序列化器和五个数据处理器作为泛型参数传递
        /// 相关的选项（可以为空）可以作为参数传递给序列化器和处理器
        /// </summary>
        /// <param name="options">Additional options to be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s</param>
        public SendReceiveOptions(Dictionary<string, string> options)
            : base(options)
        {
            DataSerializer = DPSManager.GetDataSerializer<T_DS>();
            DataProcessors = new List<DataProcessor>() {
                DPSManager.GetDataProcessor<T_DP1>(),
                DPSManager.GetDataProcessor<T_DP2>(),
                DPSManager.GetDataProcessor<T_DP3>(),
                DPSManager.GetDataProcessor<T_DP4>(),
                DPSManager.GetDataProcessor<T_DP5>() };

            if (DataSerializer == null)
                throw new InvalidOperationException("Attempted to use null DataSerializer. If this exception is thrown DPSManager.GetDataSerializer<DS>() has failed.");
        }
    }

    /// <inheritdoc />
    /// <typeparam name="T_DS">The type of <see cref="DPSBase.DataSerializer"/> to use</typeparam>
    /// <typeparam name="T_DP1">The type of the first <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP2">The type of the second <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP3">The type of the third <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP4">The type of the fourth <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP5">The type of the fifth <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP6">The type of the sixth <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    public class SendReceiveOptions<T_DS, T_DP1, T_DP2, T_DP3, T_DP4, T_DP5, T_DP6> : SendReceiveOptions
        where T_DS : DataSerializer
        where T_DP1 : DataProcessor
        where T_DP2 : DataProcessor
        where T_DP3 : DataProcessor
        where T_DP4 : DataProcessor
        where T_DP5 : DataProcessor
        where T_DP6 : DataProcessor
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class. The <see cref="DPSBase.DataSerializer"/> and 6 <see cref="DPSBase.DataProcessor"/>s while will be used are passed as generic parameters
        /// Further options can be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s as an argument which may be null
        /// 初始化一个新的SendReceiveOptions实例   数据序列化器和六个数据处理器作为泛型参数传递
        /// 相关的选项（可以为空）可以作为参数传递给序列化器和处理器
        /// </summary>
        /// <param name="options">Additional options to be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s</param>
        public SendReceiveOptions(Dictionary<string, string> options)
            : base(options)
        {
            DataSerializer = DPSManager.GetDataSerializer<T_DS>();
            DataProcessors = new List<DataProcessor>() {
                DPSManager.GetDataProcessor<T_DP1>(),
                DPSManager.GetDataProcessor<T_DP2>(),
                DPSManager.GetDataProcessor<T_DP3>(),
                DPSManager.GetDataProcessor<T_DP4>(),
                DPSManager.GetDataProcessor<T_DP5>(),
                DPSManager.GetDataProcessor<T_DP6>() };

            if (DataSerializer == null)
                throw new InvalidOperationException("Attempted to use null DataSerializer. If this exception is thrown DPSManager.GetDataSerializer<DS>() has failed.");
        }
    }

    /// <inheritdoc />
    /// <typeparam name="T_DS">The type of <see cref="DPSBase.DataSerializer"/> to use</typeparam>
    /// <typeparam name="T_DP1">The type of the first <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP2">The type of the second <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP3">The type of the third <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP4">The type of the fourth <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP5">The type of the fifth <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP6">The type of the sixth <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    /// <typeparam name="T_DP7">The type of the seventh <see cref="DPSBase.DataProcessor"/> to use</typeparam>
    public class SendReceiveOptions<T_DS, T_DP1, T_DP2, T_DP3, T_DP4, T_DP5, T_DP6, T_DP7> : SendReceiveOptions
        where T_DS : DataSerializer
        where T_DP1 : DataProcessor
        where T_DP2 : DataProcessor
        where T_DP3 : DataProcessor
        where T_DP4 : DataProcessor
        where T_DP5 : DataProcessor
        where T_DP6 : DataProcessor
        where T_DP7 : DataProcessor
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SendReceiveOptions"/> class. The <see cref="DPSBase.DataSerializer"/> and 7 <see cref="DPSBase.DataProcessor"/>s while will be used are passed as generic parameters
        /// Further options can be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s as an argument which may be null
        /// 初始化一个新的SendReceiveOptions实例   数据序列化器和七个数据处理器作为泛型参数传递
        /// 相关的选项（可以为空）可以作为参数传递给序列化器和处理器
        /// </summary>
        /// <param name="options">Additional options to be passed to the <see cref="DPSBase.DataSerializer"/> and <see cref="DPSBase.DataProcessor"/>s</param>
        public SendReceiveOptions(Dictionary<string, string> options)
            : base(options)
        {
            DataSerializer = DPSManager.GetDataSerializer<T_DS>();
            DataProcessors = new List<DataProcessor>() {
                DPSManager.GetDataProcessor<T_DP1>(),
                DPSManager.GetDataProcessor<T_DP2>(),
                DPSManager.GetDataProcessor<T_DP3>(),
                DPSManager.GetDataProcessor<T_DP4>(),
                DPSManager.GetDataProcessor<T_DP5>(),
                DPSManager.GetDataProcessor<T_DP6>(),
                DPSManager.GetDataProcessor<T_DP7>()};

            if (DataSerializer == null)
                throw new InvalidOperationException("Attempted to use null DataSerializer. If this exception is thrown DPSManager.GetDataSerializer<DS>() has failed.");
        }
    }
}