SuperSocket源码解析之配置系统

一 继承Net配置系统

   Net应用程序配置机制跟程序集引用大致类似，均具有继承性，如iis几乎每个应用程序都会有一个Web.config，比如我们使用vs2012以上版本创建一个web应用程序会自带一个web.config配置文件，这个配置文件属于整个应用程序全局配置文件，再有某些个别目录下也会存在web.config这样的配置文件，连名字都跟应用程序配置文件相同，那么他们看起来重复出现，到底是为何？

  Net的配置具有继承性，怎么理解？比如当前文件夹所拥有的配置则作用范围仅为当前文件夹，如果没有那么他们直接寻找应用程序根目录下config文件并当作自己的配置文件直到应用程序根目录，其查找顺序由下往上，由近及远，与dll引用一样本地找不到就去GAC找直到找不到；其中IIS中各个Web.Config继承性就非常的典型，所以这里也不再举例

  SuperSocket使用了Net配置系统，而不是我们平常的一个对象序列化成一个xml文件的私有配置，对比起来减少了配置文件读写次数，且net配置系统本就如此强大 

 

二 SuperSocket私有配置扩展

2.1 TypeProvider  

SuperSocket对net配置元素进行一次继承，其代码如下

public class TypeProvider : ConfigurationElement, ITypeProvider
    {
        /// <summary>
        /// Gets the name.
        /// </summary>
        [ConfigurationProperty("name", IsRequired = true)]
        public string Name
        {
            get { return this["name"] as string; }
        }

        /// <summary>
        /// Gets the type.
        /// </summary>
        [ConfigurationProperty("type", IsRequired = true)]
        public string Type
        {
            get { return this["type"] as string; }
        }
    }

扩展了Name和Type两个属性，这与SuperSocket类型提供工厂类完全对应；

 /// <summary>
    /// Provider factory infomation
    /// </summary>
    [Serializable]
    public class ProviderFactoryInfo
    {
        /// <summary>
        /// Gets the key.
        /// </summary>
        public ProviderKey Key { get; set; }

        /// <summary>
        /// Gets or sets the name.
        /// </summary>
        /// <value>
        /// The name.
        /// </value>
        public string Name { get; set; }


        /// <summary>
        /// Gets or sets the export factory.
        /// </summary>
        /// <value>
        /// The export factory.
        /// </value>
        public ExportFactory ExportFactory { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProviderFactoryInfo"/> class.
        /// </summary>
        public ProviderFactoryInfo()
        {

        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProviderFactoryInfo"/> class.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="name">The name.</param>
        /// <param name="instance">The instance.</param>
        public ProviderFactoryInfo(ProviderKey key, string name, object instance)
        {
            Key = key;
            Name = name;
            ExportFactory = new ExportFactory(instance);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProviderFactoryInfo"/> class.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="name">The name.</param>
        /// <param name="typeName">Name of the type.</param>
        public ProviderFactoryInfo(ProviderKey key, string name, string typeName)
        {
            Key = key;
            Name = name;
            ExportFactory = new ExportFactory(typeName);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProviderFactoryInfo"/> class.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="name">The name.</param>
        /// <param name="type">The type.</param>
        public ProviderFactoryInfo(ProviderKey key, string name, Type type)
            : this(key, name, type.AssemblyQualifiedName)
        {
            
        }
    }

从代码上可以看出只要有Name和Type这2个参数即可构造一个ProviderFactoryInfo类的实例

2.2 TypeProviderCollection 扩展的TypeProvider类型集合

[ConfigurationCollection(typeof(TypeProvider))]
    public class TypeProviderCollection : ConfigurationElementCollection, IEnumerable<ITypeProvider>
    {
        /// <summary>
        /// When overridden in a derived class, creates a new <see cref="T:System.Configuration.ConfigurationElement"/>.
        /// </summary>
        /// <returns>
        /// A new <see cref="T:System.Configuration.ConfigurationElement"/>.
        /// </returns>
        protected override ConfigurationElement CreateNewElement()
        {
            return new TypeProvider() as ConfigurationElement;
        }

        /// <summary>
        /// Gets the element key for a specified configuration element when overridden in a derived class.
        /// </summary>
        /// <param name="element">The <see cref="T:System.Configuration.ConfigurationElement"/> to return the key for.</param>
        /// <returns>
        /// An <see cref="T:System.Object"/> that acts as the key for the specified <see cref="T:System.Configuration.ConfigurationElement"/>.
        /// </returns>
        protected override object GetElementKey(ConfigurationElement element)
        {
            var provider = element as TypeProvider;

            if (provider == null)
                return null;

            return provider.Name;
        }

        /// <summary>
        /// Returns an enumerator that iterates through the collection.
        /// </summary>
        /// <returns>
        /// A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
        /// </returns>
        public new IEnumerator<ITypeProvider> GetEnumerator()
        {
            int count = base.Count;

            for (int i = 0; i < count; i++)
            {
                yield return (ITypeProvider)base.BaseGet(i);
            }
        }
    }

 

三 SuperSocket配置内容

3.1 全局配置

如图红色部分所示，SuperSocket的所有配置均包裹在SocketServiceConfig这类型中，且成为App.config的一个配置节点section，那么SocketServiceConfig又包含了什么呢？

public partial class SocketServiceConfig : ConfigurationSection, IConfigurationSource
    {
        /// <summary>
        /// Gets all the server configurations
        /// </summary>
        [ConfigurationProperty("servers")]
        public ServerCollection Servers
        {
            get
            {
                return this["servers"] as ServerCollection;
            }
        }

        /// <summary>
        /// Gets the service configurations
        /// </summary>
        [ConfigurationProperty("serverTypes")]
        public TypeProviderCollection ServerTypes
        {
            get
            {
                return this["serverTypes"] as TypeProviderCollection;
            }
        }

        /// <summary>
        /// Gets all the connection filter configurations.
        /// </summary>
        [ConfigurationProperty("connectionFilters", IsRequired = false)]
        public TypeProviderCollection ConnectionFilters
        {
            get
            {
                return this["connectionFilters"] as TypeProviderCollection;
            }
        }

        /// <summary>
        /// Gets the defined log factory types.
        /// </summary>
        [ConfigurationProperty("logFactories", IsRequired = false)]
        public TypeProviderCollection LogFactories
        {
            get
            {
                return this["logFactories"] as TypeProviderCollection;
            }
        }

        /// <summary>
        /// Gets the logfactory name of the bootstrap.
        /// </summary>
        [ConfigurationProperty("receiveFilterFactories", IsRequired = false)]
        public TypeProviderCollection ReceiveFilterFactories
        {
            get
            {
                return this["receiveFilterFactories"] as TypeProviderCollection;
            }
        }

        /// <summary>
        /// Gets the command loaders definition.
        /// </summary>
        [ConfigurationProperty("commandLoaders", IsRequired = false)]
        public TypeProviderCollection CommandLoaders
        {
            get
            {
                return this["commandLoaders"] as TypeProviderCollection;
            }
        }

        /// <summary>
        /// Gets the max working threads.
        /// </summary>
        [ConfigurationProperty("maxWorkingThreads", IsRequired = false, DefaultValue = -1)]
        public int MaxWorkingThreads
        {
            get
            {
                return (int)this["maxWorkingThreads"];
            }
        }

        /// <summary>
        /// Gets the min working threads.
        /// </summary>
        [ConfigurationProperty("minWorkingThreads", IsRequired = false, DefaultValue = -1)]
        public int MinWorkingThreads
        {
            get
            {
                return (int)this["minWorkingThreads"];
            }
        }

        /// <summary>
        /// Gets the max completion port threads.
        /// </summary>
        [ConfigurationProperty("maxCompletionPortThreads", IsRequired = false, DefaultValue = -1)]
        public int MaxCompletionPortThreads
        {
            get
            {
                return (int)this["maxCompletionPortThreads"];
            }
        }

        /// <summary>
        /// Gets the min completion port threads.
        /// </summary>
        [ConfigurationProperty("minCompletionPortThreads", IsRequired = false, DefaultValue = -1)]
        public int MinCompletionPortThreads
        {
            get
            {
                return (int)this["minCompletionPortThreads"];
            }
        }

        /// <summary>
        /// Gets the performance data collect interval, in seconds.
        /// </summary>
        [ConfigurationProperty("performanceDataCollectInterval", IsRequired = false, DefaultValue = 60)]
        public int PerformanceDataCollectInterval
        {
            get
            {
                return (int)this["performanceDataCollectInterval"];
            }
        }

        /// <summary>
        /// Gets a value indicating whether [disable performance data collector].
        /// </summary>
        /// <value>
        ///     <c>true</c> if [disable performance data collector]; otherwise, <c>false</c>.
        /// </value>
        [ConfigurationProperty("disablePerformanceDataCollector", IsRequired = false, DefaultValue = false)]
        public bool DisablePerformanceDataCollector
        {
            get
            {
                return (bool)this["disablePerformanceDataCollector"];
            }
        }

        /// <summary>
        /// Gets the isolation mode.
        /// </summary>
        [ConfigurationProperty("isolation", IsRequired = false, DefaultValue = IsolationMode.None)]
        public IsolationMode Isolation
        {
            get { return (IsolationMode)this["isolation"]; }
        }

        /// <summary>
        /// Gets the logfactory name of the bootstrap.
        /// </summary>
        [ConfigurationProperty("logFactory", IsRequired = false, DefaultValue = "")]
        public string LogFactory
        {
            get
            {
                return (string)this["logFactory"];
            }
        }

        /// <summary>
        /// Gets the option elements.
        /// </summary>
        public NameValueCollection OptionElements { get; private set; }

        /// <summary>
        /// Gets a value indicating whether an unknown element is encountered during deserialization.
        /// To keep compatible with old configuration
        /// </summary>
        /// <param name="elementName">The name of the unknown subelement.</param>
        /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> being used for deserialization.</param>
        /// <returns>
        /// true when an unknown element is encountered while deserializing; otherwise, false.
        /// </returns>
        /// <exception cref="T:System.Configuration.ConfigurationErrorsException">The element identified by <paramref name="elementName"/> is locked.- or -One or more of the element's attributes is locked.- or -<paramref name="elementName"/> is unrecognized, or the element has an unrecognized attribute.- or -The element has a Boolean attribute with an invalid value.- or -An attempt was made to deserialize a property more than once.- or -An attempt was made to deserialize a property that is not a valid member of the element.- or -The element cannot contain a CDATA or text element.</exception>
        protected override bool OnDeserializeUnrecognizedElement(string elementName, System.Xml.XmlReader reader)
        {
            //To keep compatible with old configuration
            if (!"services".Equals(elementName, StringComparison.OrdinalIgnoreCase))
            {
                if (OptionElements == null)
                    OptionElements = new NameValueCollection();

                OptionElements.Add(elementName, reader.ReadOuterXml());
                return true;
            }

            var serverTypes = new TypeProviderCollection();
            reader.Read();
            serverTypes.Deserialize(reader);

            this["serverTypes"] = serverTypes;

            return true;
        }

        /// <summary>
        /// Gets a value indicating whether an unknown attribute is encountered during deserialization.
        /// </summary>
        /// <param name="name">The name of the unrecognized attribute.</param>
        /// <param name="value">The value of the unrecognized attribute.</param>
        /// <returns>
        /// true when an unknown attribute is encountered while deserializing; otherwise, false.
        /// </returns>
        protected override bool OnDeserializeUnrecognizedAttribute(string name, string value)
        {
            const string xmlns = "xmlns";
            const string xmlnsPrefix = "xmlns:";
            const string xsiPrefix = "xsi:";

            //for configuration intellisense, allow these unrecognized attributes: xmlns, xmlns:*, xsi:*
            if (name.Equals(xmlns) || name.StartsWith(xmlnsPrefix) || name.StartsWith(xsiPrefix))
                return true;

            return false;
        }

        /// <summary>
        /// Gets the child config.
        /// </summary>
        /// <typeparam name="TConfig">The type of the config.</typeparam>
        /// <param name="childConfigName">Name of the child config.</param>
        /// <returns></returns>
        public TConfig GetChildConfig<TConfig>(string childConfigName)
            where TConfig : ConfigurationElement, new()
        {
            return this.OptionElements.GetChildConfig<TConfig>(childConfigName);
        }

        IEnumerable<IServerConfig> IConfigurationSource.Servers
        {
            get
            {
                return this.Servers;
            }
        }

        IEnumerable<ITypeProvider> IConfigurationSource.ServerTypes
        {
            get
            {
                return this.ServerTypes;
            }
        }

        IEnumerable<ITypeProvider> IConfigurationSource.ConnectionFilters
        {
            get
            {
                return this.ConnectionFilters;
            }
        }

        IEnumerable<ITypeProvider> IConfigurationSource.LogFactories
        {
            get
            {
                return this.LogFactories;
            }
        }

        IEnumerable<ITypeProvider> IConfigurationSource.ReceiveFilterFactories
        {
            get
            {
                return this.ReceiveFilterFactories;
            }
        }


        IEnumerable<ITypeProvider> IConfigurationSource.CommandLoaders
        {
            get
            {
                return this.CommandLoaders;
            }
        }
    }

1）Servers服务实例；

　　集合：AppServer有多少appserver实例

2）ServerTypes服务类型ServerTypes

　　集合：继承AppServer的子类型

3）ConnectionFilters

　　集合：说明了有多少个连接过滤工厂类型

4）LogFactories

     集合：说明了有多少个日志工厂类型

5）ReceiveFilterFactories

　　集合：说明了有多少个协议解析工厂类型

6）CommandLoaders

　　集合：说明了有多少个命令加载工厂类型

7）MaxWorkingThreads

　　app最大工作线程数，主要用于配置ThreadPool

 等等，这里可以详细参考官方文档SuperSocket配置：http://docs.supersocket.net/v1-6/zh-CN/SuperSocket-Basic-Configuration

其中类型的配置示例

 <serverTypes>

   <add name="TelnetServer" type="SuperSocket.QuickStart.TelnetServer_StartByConfig.TelnetServer, SuperSocket.QuickStart.TelnetServer_StartByConfig"/
</serverTypes>

 

均是TypeProvider，只需指定Name和type即可

 

 

 3.2 服务配置

与之对应的类型ServerConfig，每个详细的配置均有默认值

public partial class ServerConfig : IServerConfig
    {
        /// <summary>
        /// Default ReceiveBufferSize
        /// </summary>
        public const int DefaultReceiveBufferSize = 4096;

        /// <summary>
        /// Default MaxConnectionNumber
        /// </summary>
        public const int DefaultMaxConnectionNumber = 100;


        /// <summary>
        /// Default sending queue size
        /// </summary>
        public const int DefaultSendingQueueSize = 5;

        /// <summary>
        /// Default MaxRequestLength
        /// </summary>
        public const int DefaultMaxRequestLength = 1024;


        /// <summary>
        /// Default send timeout value, in milliseconds
        /// </summary>
        public const int DefaultSendTimeout = 5000;


        /// <summary>
        /// Default clear idle session interval
        /// </summary>
        public const int DefaultClearIdleSessionInterval = 120;


        /// <summary>
        /// Default idle session timeout
        /// </summary>
        public const int DefaultIdleSessionTimeOut = 300;


        /// <summary>
        /// The default send buffer size
        /// </summary>
        public const int DefaultSendBufferSize = 2048;


        /// <summary>
        /// The default session snapshot interval
        /// </summary>
        public const int DefaultSessionSnapshotInterval = 5;

        /// <summary>
        /// The default keep alive time
        /// </summary>
        public const int DefaultKeepAliveTime = 600; // 60 * 10 = 10 minutes


        /// <summary>
        /// The default keep alive interval
        /// </summary>
        public const int DefaultKeepAliveInterval = 60; // 60 seconds


        /// <summary>
        /// The default listen backlog
        /// </summary>
        public const int DefaultListenBacklog = 100;


        /// <summary>
        /// Initializes a new instance of the <see cref="ServerConfig"/> class.
        /// </summary>
        /// <param name="serverConfig">The server config.</param>
        public ServerConfig(IServerConfig serverConfig)
        {
            serverConfig.CopyPropertiesTo(this);
            
            this.Options = serverConfig.Options;
            this.OptionElements = serverConfig.OptionElements;

            if (serverConfig.Certificate != null)
                this.Certificate = serverConfig.Certificate.CopyPropertiesTo(new CertificateConfig());

            if (serverConfig.Listeners != null && serverConfig.Listeners.Any())
            {
                this.Listeners = serverConfig.Listeners.Select(l => l.CopyPropertiesTo(new ListenerConfig())).OfType<ListenerConfig>().ToArray();
            }

            if (serverConfig.CommandAssemblies != null && serverConfig.CommandAssemblies.Any())
            {
                this.CommandAssemblies = serverConfig.CommandAssemblies.Select(c => c.CopyPropertiesTo(new CommandAssemblyConfig())).OfType<CommandAssemblyConfig>().ToArray();
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ServerConfig"/> class.
        /// </summary>
        public ServerConfig()
        {
            Security = "None";
            MaxConnectionNumber = DefaultMaxConnectionNumber;
            Mode = SocketMode.Tcp;
            MaxRequestLength = DefaultMaxRequestLength;
            KeepAliveTime = DefaultKeepAliveTime;
            KeepAliveInterval = DefaultKeepAliveInterval;
            ListenBacklog = DefaultListenBacklog;
            ReceiveBufferSize = DefaultReceiveBufferSize;
            SendingQueueSize = DefaultSendingQueueSize;
            SendTimeOut = DefaultSendTimeout;
            ClearIdleSessionInterval = DefaultClearIdleSessionInterval;
            IdleSessionTimeOut = DefaultIdleSessionTimeOut;
            SendBufferSize = DefaultSendBufferSize;
            LogBasicSessionActivity = true;
            SessionSnapshotInterval = DefaultSessionSnapshotInterval;
        }

        #region IServerConfig Members

        /// <summary>
        /// Gets/sets the name of the server type of this appServer want to use.
        /// </summary>
        /// <value>
        /// The name of the server type.
        /// </value>
        public string ServerTypeName { get; set; }


        /// <summary>
        /// Gets/sets the type definition of the appserver.
        /// </summary>
        /// <value>
        /// The type of the server.
        /// </value>
        public string ServerType { get; set; }

        /// <summary>
        /// Gets/sets the Receive filter factory.
        /// </summary>
        public string ReceiveFilterFactory { get; set; }

        /// <summary>
        /// Gets/sets the ip.
        /// </summary>
        public string Ip { get; set; }

        /// <summary>
        /// Gets/sets the port.
        /// </summary>
        public int Port { get; set; }

        /// <summary>
        /// Gets/sets the options.
        /// </summary>
        public NameValueCollection Options { get; set; }

        /// <summary>
        /// Gets the option elements.
        /// </summary>
        public NameValueCollection OptionElements { get; set; }

        /// <summary>
        /// Gets/sets a value indicating whether this <see cref="IServerConfig"/> is disabled.
        /// </summary>
        /// <value>
        ///   <c>true</c> if disabled; otherwise, <c>false</c>.
        /// </value>
        public bool Disabled { get; set; }

        /// <summary>
        /// Gets the name.
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// Gets/sets the mode.
        /// </summary>
        public SocketMode Mode { get; set; }

        /// <summary>
        /// Gets/sets the send time out.
        /// </summary>
        public int SendTimeOut { get; set; }

        /// <summary>
        /// Gets the max connection number.
        /// </summary>
        public int MaxConnectionNumber { get; set; }

        /// <summary>
        /// Gets the size of the receive buffer.
        /// </summary>
        /// <value>
        /// The size of the receive buffer.
        /// </value>
        public int ReceiveBufferSize { get; set; }

        /// <summary>
        /// Gets the size of the send buffer.
        /// </summary>
        /// <value>
        /// The size of the send buffer.
        /// </value>
        public int SendBufferSize { get; set; }


        /// <summary>
        /// Gets a value indicating whether sending is in synchronous mode.
        /// </summary>
        /// <value>
        ///   <c>true</c> if [sync send]; otherwise, <c>false</c>.
        /// </value>
        public bool SyncSend { get; set; }

        /// <summary>
        /// Gets/sets a value indicating whether log command in log file.
        /// </summary>
        /// <value>
        ///   <c>true</c> if log command; otherwise, <c>false</c>.
        /// </value>
        public bool LogCommand { get; set; }

        /// <summary>
        /// Gets/sets a value indicating whether clear idle session.
        /// </summary>
        /// <value>
        ///   <c>true</c> if clear idle session; otherwise, <c>false</c>.
        /// </value>
        public bool ClearIdleSession { get; set; }

        /// <summary>
        /// Gets/sets the clear idle session interval, in seconds.
        /// </summary>
        /// <value>
        /// The clear idle session interval.
        /// </value>
        public int ClearIdleSessionInterval { get; set; }

        /// <summary>
        /// Gets/sets the idle session timeout time length, in seconds.
        /// </summary>
        /// <value>
        /// The idle session time out.
        /// </value>
        public int IdleSessionTimeOut { get; set; }

        /// <summary>
        /// Gets/sets X509Certificate configuration.
        /// </summary>
        /// <value>
        /// X509Certificate configuration.
        /// </value>
        public ICertificateConfig Certificate { get; set; }

        /// <summary>
        /// Gets/sets the security protocol, X509 certificate.
        /// </summary>
        public string Security { get; set; }

        /// <summary>
        /// Gets/sets the length of the max request.
        /// </summary>
        /// <value>
        /// The length of the max request.
        /// </value>
        public int MaxRequestLength { get; set; }

        /// <summary>
        /// Gets/sets a value indicating whether [disable session snapshot].
        /// </summary>
        /// <value>
        ///     <c>true</c> if [disable session snapshot]; otherwise, <c>false</c>.
        /// </value>
        public bool DisableSessionSnapshot { get; set; }

        /// <summary>
        /// Gets/sets the interval to taking snapshot for all live sessions.
        /// </summary>
        public int SessionSnapshotInterval { get; set; }

        /// <summary>
        /// Gets/sets the connection filters used by this server instance.
        /// </summary>
        /// <value>
        /// The connection filter's name list, seperated by comma
        /// </value>
        public string ConnectionFilter { get; set; }

        /// <summary>
        /// Gets the command loader, multiple values should be separated by comma.
        /// </summary>
        public string CommandLoader { get; set; }

        /// <summary>
        /// Gets/sets the start keep alive time, in seconds
        /// </summary>
        public int KeepAliveTime { get; set; }

        /// <summary>
        /// Gets/sets the keep alive interval, in seconds.
        /// </summary>
        public int KeepAliveInterval { get; set; }

        /// <summary>
        /// Gets the backlog size of socket listening.
        /// </summary>
        public int ListenBacklog { get; set; }

        /// <summary>
        /// Gets/sets the startup order of the server instance.
        /// </summary>
        public int StartupOrder { get; set; }

        /// <summary>
        /// Gets the child config.
        /// </summary>
        /// <typeparam name="TConfig">The type of the config.</typeparam>
        /// <param name="childConfigName">Name of the child config.</param>
        /// <returns></returns>
        public virtual TConfig GetChildConfig<TConfig>(string childConfigName)
            where TConfig : ConfigurationElement, new()
        {
            return this.OptionElements.GetChildConfig<TConfig>(childConfigName);
        }

        /// <summary>
        /// Gets and sets the listeners' configuration.
        /// </summary>
        public IEnumerable<IListenerConfig> Listeners { get; set; }

        /// <summary>
        /// Gets/sets the log factory name.
        /// </summary>
        public string LogFactory { get; set; }

        /// <summary>
        /// Gets/sets the size of the sending queue.
        /// </summary>
        /// <value>
        /// The size of the sending queue.
        /// </value>
        public int SendingQueueSize { get; set; }

        /// <summary>
        /// Gets a value indicating whether [log basic session activity like connected and disconnected].
        /// </summary>
        /// <value>
        ///     <c>true</c> if [log basic session activity]; otherwise, <c>false</c>.
        /// </value>
        public bool LogBasicSessionActivity { get; set; }

        /// <summary>
        /// Gets/sets a value indicating whether [log all socket exception].
        /// </summary>
        /// <value>
        /// <c>true</c> if [log all socket exception]; otherwise, <c>false</c>.
        /// </value>
        public bool LogAllSocketException { get; set; }

        /// <summary>
        /// Gets/sets the default text encoding.
        /// </summary>
        /// <value>
        /// The text encoding.
        /// </value>
        public string TextEncoding { get; set; }

        /// <summary>
        /// Gets the command assemblies configuration.
        /// </summary>
        /// <value>
        /// The command assemblies.
        /// </value>
        public IEnumerable<ICommandAssemblyConfig> CommandAssemblies { get; set; }

        #endregion
    }

其详细可参考代码和文档：

http://docs.supersocket.net/v1-6/zh-CN/Start-SuperSocket-by-Configuration：重配置启动

http://docs.supersocket.net/v1-6/zh-CN/SuperSocket-Basic-Configuration：服务实例配置

 

3.3 IRootConfig

 这是最顶层的配置，从代码可以看出是对全局进行基础性配置，同时也是大部分配置实现了，如SocketServiceConfig

public partial interface IRootConfig
    {
        /// <summary>
        /// Gets the max working threads.
        /// </summary>
        int MaxWorkingThreads { get; }

        /// <summary>
        /// Gets the min working threads.
        /// </summary>
        int MinWorkingThreads { get; }

        /// <summary>
        /// Gets the max completion port threads.
        /// </summary>
        int MaxCompletionPortThreads { get; }

        /// <summary>
        /// Gets the min completion port threads.
        /// </summary>
        int MinCompletionPortThreads { get; }


        /// <summary>
        /// Gets a value indicating whether [disable performance data collector].
        /// </summary>
        /// <value>
        ///     <c>true</c> if [disable performance data collector]; otherwise, <c>false</c>.
        /// </value>
        bool DisablePerformanceDataCollector { get; }

        /// <summary>
        /// Gets the performance data collect interval, in seconds.
        /// </summary>
        int PerformanceDataCollectInterval { get; }


        /// <summary>
        /// Gets the log factory name.
        /// </summary>
        /// <value>
        /// The log factory.
        /// </value>
        string LogFactory { get; }


        /// <summary>
        /// Gets the isolation mode.
        /// </summary>
        IsolationMode Isolation { get; }


        /// <summary>
        /// Gets the option elements.
        /// </summary>
        NameValueCollection OptionElements { get; }

        /// <summary>
        /// Gets the child config.
        /// </summary>
        /// <typeparam name="TConfig">The type of the config.</typeparam>
        /// <param name="childConfigName">Name of the child config.</param>
        /// <returns></returns>
        TConfig GetChildConfig<TConfig>(string childConfigName)
            where TConfig : ConfigurationElement, new();
    }

 

四 配置如何使用

诚然net的配置是非常方便的只需一句代码即可

var configSection = ConfigurationManager.GetSection("superSocket");即可拿到所有Supersocket的配置

 

五 根据配置启动

  在所提供的代码中大多数都是以配置启动服务器，将SuperSocket直接作为app，那么其启动入口则有BootstrapFactory开始

 

5.1 引导程序开始

public static IBootstrap CreateBootstrap()
{
　　var configSection = ConfigurationManager.GetSection("superSocket");

　　if (configSection == null)//to keep compatible with old version
　　　　configSection = ConfigurationManager.GetSection("socketServer");

　　if(configSection == null)
　　　　throw new ConfigurationErrorsException("Missing 'superSocket' or 'socketServer' configuration section.");

　　var configSource = configSection as IConfigurationSource;
　　if(configSource == null)
　　　　throw new ConfigurationErrorsException("Invalid 'superSocket' or 'socketServer' configuration section.");

　　return CreateBootstrap(configSource);
}

5.2 appserver工厂代理加载器

public List<WorkItemFactoryInfo> LoadResult(Func<IServerConfig, IServerConfig> serverConfigResolver)
通过代理直接将所配置的类型提供信息解析成 ProviderFactoryInfo他们只是封装了name和type但是可以导出各类工厂如LogFactory，这里就直接转到了工厂设计模式频道了

然后将所有这些ProviderFactoryInfo成为WorkItemFactoryInfo的配套也就是说每个AppServer的配套，AppServer所需要的如Log，SocketServer均由ProviderFactoryInfo所导出的与之相应的LogFactory，SocketServerFactory创建，并且将配置作为这些对象初始化参数

5.3 启动所有Server

 

六 默认配置

6.1 默认全局日志

由Log4NetFactory创建，代码位置

 

6.2 AppServer 默认日志

Log4NetFactory

6.3 默认的SocketServerFactroy

workItemFactory.SocketServerFactory = new ProviderFactoryInfo(ProviderKey.SocketServerFactory, string.Empty, typeof(SocketServerFactory));

6.4 默认的协议

且使用换行符作为结束标志，如发送一条消息 echo xxd ccc;那么解析后key：echo，body:xxd ccc ，params：xxd,ccc，其中参数以空格为分割

6.5 连接过滤

没有默认

6.6 命令加载器

ReflectCommandLoader

 

 

 

 

七 配置改变

 

http://docs.supersocket.net/v1-6/zh-CN/Server-Configuration-Hot-Update