Wpf_AiSportsMicrospace/sdks/Yunzhi.Library.xml

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Yunzhi.Library</name>
    </assembly>
    <members>
        <member name="T:Yunzhi.Caching.Cache">
            <summary>
            表示一个缓存实例
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.Cache.Key">
            <summary>
            获取缓存队列全局维一键
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.Cache.Provider">
            <summary>
            获取当前缓存的存储提供程序
            </summary>
        </member>
        <member name="M:Yunzhi.Caching.Cache.#ctor(System.String,Yunzhi.Caching.ICacheProvider)">
            <summary>
            初始化缓存实例
            </summary>
            <param name="key">缓存键</param>
            <param name="provider">缓存提供程序</param>
        </member>
        <member name="M:Yunzhi.Caching.Cache.Set``1(System.String,``0,System.Nullable{System.TimeSpan},System.Boolean)">
            <summary>
            设定缓存项值
            </summary>
            <param name="key">缓存项键</param>
            <param name="value">缓存项值</param>
            <param name="expired">缓存项过期时长，null按默认过期时间处理(如果Session将默认20分钟超时)，TimeSpan.Zero则最永久有效</param>
            <param name="extended">设定缓存过期时间是不是自动延展.</param>
            <typeparam name="T">缓存值的类型</typeparam>
        </member>
        <member name="M:Yunzhi.Caching.Cache.Set``1(System.String,``0,System.Int32,System.Boolean)">
            <summary>
            设定缓存项值
            </summary>
            <param name="key">缓存项键</param>
            <param name="value">缓存项值</param>
            <param name="expired">缓存项过期时长（单位秒），0永不过期</param>
            <param name="extended">设定缓存过期时间是不是自动延展.</param>
            <typeparam name="T">缓存值的类型</typeparam>
        </member>
        <member name="M:Yunzhi.Caching.Cache.Remove(System.String)">
            <summary>
            移除指定键缓存项
            </summary>
            <param name="key">缓存项键</param>
        </member>
        <member name="M:Yunzhi.Caching.Cache.Exists(System.String)">
            <summary>
            确认指定键的缓存项是否存在
            </summary>
            <param name="key">缓存项键</param>
            <returns>true存在;false不存在</returns>
        </member>
        <member name="M:Yunzhi.Caching.Cache.Get``1(System.String,System.Func{``0},System.Nullable{System.TimeSpan})">
            <summary>
            获取指定的缓存，如果指定缓存不存在则调用<paramref name="geter"/>回调获取
            </summary>
            <param name="key">缓存项键</param>
            <param name="geter">缓存项值获取器</param>
            <param name="expired">设定<paramref name="key"/>缓存项过期时长；如果未设定<paramref name="geter"/>参数则会忽略此参数</param>
            <returns>
            未设定geter时，如果不存在则返回null，否则返回相应值
            设定geter时，一定会返回值
            </returns>
            <exception cref="T:System.Exception">调用<paramref name="geter"/>时没有返回值</exception>
        </member>
        <member name="T:Yunzhi.Caching.CacheItem">
            <summary>
            表示一个缓存项
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.CacheItem.Key">
            <summary>
            获取缓存项键
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.CacheItem.Value">
            <summary>
            获取或者设定缓存项值
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.CacheItem.Expired">
            <summary>
            获取或者设定过期时间，null按默认过期时间处理，TimeSpan.Zero则最永久有效
            </summary>
            <remarks>
            设置当前属性后，会以自动当前时间计算<see cref="P:Yunzhi.Caching.CacheItem.ExpiredTime"/>，并赋值。
            设置本属性主要是为了<see cref="P:Yunzhi.Caching.CacheItem.Extended"/>延展需要。
            </remarks>
        </member>
        <member name="P:Yunzhi.Caching.CacheItem.ExpiredTime">
            <summary>
            获取或者设置缓存项到期时间。
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.CacheItem.Extended">
            <summary>
            获取或设置当前缓存项是否自动顺延过期时间。
            </summary>
        </member>
        <member name="M:Yunzhi.Caching.CacheItem.#ctor(System.String)">
            <summary>
            初始化一个缓存项
            </summary>
            <param name="key">缓存项键</param>
        </member>
        <member name="T:Yunzhi.Caching.CachePool">
            <summary>
            缓存池
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.CachePool.Instance">
            <summary>
            获取缓存池唯一实例
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.CachePool.Configuration">
            <summary>
            获取缓存的配置
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.CachePool.Item(System.String)">
            <summary>
            获取指定键缓存实例
            </summary>
            <param name="key">缓存实例键</param>
            <returns>缓存实例</returns>
            <remarks>如果已经在<seealso cref="P:Yunzhi.Caching.Configuration.CacheSection.Pool"/></remarks>
        </member>
        <member name="P:Yunzhi.Caching.CachePool.Default">
            <summary>
            获取默认缓存
            </summary>
        </member>
        <member name="M:Yunzhi.Caching.CachePool.#ctor">
            <summary>
            创建缓存池实例
            </summary>
            <remarks>会创建一个键为default的默认缓存</remarks>
        </member>
        <member name="M:Yunzhi.Caching.CachePool.New(System.String)">
            <summary>
            以默认提供程序向缓存池添加一个缓存。
            </summary>
            <param name="key">缓存键</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Caching.CachePool.New(System.String,Yunzhi.Caching.ICacheProvider)">
            <summary>
            创建一个新的缓存
            </summary>
            <param name="key">缓存键</param>
            <param name="provider">缓存提供程序</param>
            <returns>新创建的缓存</returns>
        </member>
        <member name="M:Yunzhi.Caching.CachePool.Remove(System.String)">
            <summary>
            移除指定的缓存实例
            </summary>
            <param name="key">缓存实例键</param>
        </member>
        <member name="M:Yunzhi.Caching.CachePool.Get(System.String,System.Func{Yunzhi.Caching.ICacheProvider})">
            <summary>
            获取指定键的缓存实例，如果不存在且指定了<paramref name="provider"/>则调用创建。
            </summary>
            <param name="key">缓存实例键</param>
            <param name="provider">缓存Cache程序提供者</param>
            <returns>缓存实例</returns>
        </member>
        <member name="T:Yunzhi.Caching.Configuration.CacheInstanceElement">
            <summary>
            表示一个缓存实例配置元素
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.Configuration.CacheInstanceElement.Key">
            <summary>
            获取或设置缓存Key
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.Configuration.CacheInstanceElement.Provider">
            <summary>
            获取或设置缓存提供程序
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.Configuration.CacheInstanceElement.Parameters">
            <summary>
            获取或设置缓存提供程序要配置的其它参数
            </summary>
        </member>
        <member name="T:Yunzhi.Caching.Configuration.CacheSection">
            <summary>
            表示缓存配置节
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.Configuration.CacheSection.DefaultProvider">
            <summary>
            获取或设置默认缓存提供程序
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.Configuration.CacheSection.Parameters">
            <summary>
            获取或设置缓存提供程序需要的其它参数
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.Configuration.CacheSection.Pool">
            <summary>
            获取或设置缓存池，实例配置
            </summary>
        </member>
        <member name="T:Yunzhi.Caching.ICacheProvider">
            <summary>
            缓存提供程序接口
            </summary>
        </member>
        <member name="P:Yunzhi.Caching.ICacheProvider.Key">
            <summary>
            获取或设置缓存的唯一键
            </summary>
        </member>
        <member name="M:Yunzhi.Caching.ICacheProvider.Set``1(System.String,``0,System.Nullable{System.TimeSpan},System.Boolean)">
            <summary>
            设定指定键缓存值
            </summary>
            <param name="key">缓存项键</param>
            <param name="value">缓存项值</param>
            <param name="expired">缓存项过期时长，null按默认过期时间处理，TimeSpan.Zero则最永久有效</param>
            <param name="extended">表示每次访问后是否将缓存顺延相应的时间。</param>
            <typeparam name="T">缓存的 值类型</typeparam>
            <remarks>如果缓存存在更新缓存值，否则创建一个新的缓存</remarks>
        </member>
        <member name="M:Yunzhi.Caching.ICacheProvider.Remove(System.String)">
            <summary>
            移除指定键缓存
            </summary>
            <param name="key">缓存项键</param>
        </member>
        <member name="M:Yunzhi.Caching.ICacheProvider.Exists(System.String)">
            <summary>
            确认指定键的值是否存在当前缓存
            </summary>
            <param name="key">缓存项键</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Caching.ICacheProvider.Get``1(System.String)">
            <summary>
            获取指定键缓存值
            </summary>
            <param name="key">缓存项键</param>
            <typeparam name="T">缓存的 值类型</typeparam>
            <returns>存在返回值，否则返回<typeparamref name="T"/>的默认类型。</returns>
        </member>
        <member name="M:Yunzhi.Caching.ICacheProvider.Clean">
            <summary>
            清理掉已经过期的缓存
            </summary>
        </member>
        <member name="M:Yunzhi.Caching.ICacheProvider.Count">
            <summary>
            获取或设置当前已经缓存的条目数。
            </summary>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Caching.MemoryProvider">
            <summary>
            内存缓存提供程序。
            </summary>
        </member>
        <member name="M:Yunzhi.Caching.MemoryProvider.#ctor(System.String)">
            <summary>
            初始化提供程序
            </summary>
            <param name="key">实例唯一</param>
        </member>
        <member name="M:Yunzhi.Caching.MemoryProvider.#ctor(System.String,Yunzhi.Caching.Configuration.CacheInstanceElement)">
            <summary>
            使用缓存池配置初始化提供程序
            </summary>
            <param name="key">实例唯一键</param>
            <param name="config">配置实例</param>
        </member>
        <member name="P:Yunzhi.Caching.MemoryProvider.Key">
            <summary>
            获取或设置当前提供程序的缓存唯一键
            </summary>
        </member>
        <member name="M:Yunzhi.Caching.MemoryProvider.Set``1(System.String,``0,System.Nullable{System.TimeSpan},System.Boolean)">
            <summary>
            设定指定键缓存值
            </summary>
            <param name="key">缓存项键</param>
            <param name="value">缓存项值</param>
            <param name="expired">缓存项过期时长，null按默认过期时间处理，TimeSpan.Zero则最永久有效</param>
            <param name="extended">表示每次访问后是否将缓存顺延相应的时间。</param>
            <typeparam name="T">缓存的值类型</typeparam>
            <remarks>如果缓存存在更新缓存值，否则创建一个新的缓存</remarks>
        </member>
        <member name="M:Yunzhi.Caching.MemoryProvider.Remove(System.String)">
            <summary>
            移除指定键缓存
            </summary>
            <param name="key">缓存项键</param>
        </member>
        <member name="M:Yunzhi.Caching.MemoryProvider.Exists(System.String)">
            <summary>
            确认指定键的值是否存在当前缓存
            </summary>
            <param name="key">缓存项键</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Caching.MemoryProvider.Get``1(System.String)">
            <summary>
            获取指定键缓存值
            </summary>
            <param name="key">缓存项键</param>
            <typeparam name="T">缓存的 值类型</typeparam>
            <returns>存在返回值，否则返回<typeparamref name="T"/>的默认类型。</returns>
        </member>
        <member name="M:Yunzhi.Caching.MemoryProvider.Clean">
            <summary>
            清理掉过已经过期的缓存
            </summary>
        </member>
        <member name="M:Yunzhi.Caching.MemoryProvider.Count">
            <summary>
            获取或设置当前已经缓存的条目数。
            </summary>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Common.AssemblyExtends">
            <summary>
            程序集相关扩展工具方法
            </summary>
        </member>
        <member name="M:Yunzhi.Common.AssemblyExtends.GetVersion(System.Reflection.Assembly)">
            <summary>
            获取程序集版本
            </summary>
            <param name="assembly">程序集实例</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.AssemblyExtends.GetInformationalVersion(System.Reflection.Assembly)">
            <summary>
            获取程序集产品版本
            </summary>
            <param name="assembly">程序集实例</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.AssemblyExtends.GetBuildTime(System.Reflection.Assembly)">
            <summary>
            获取程序集编译时间
            </summary>
            <param name="assembly">程序集实例</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.AssemblyExtends.GetFullVersion(System.Reflection.Assembly,System.String)">
            <summary>
            获取完全的版本信息
            </summary>
            <param name="assembly">程序集实例</param>
            <param name="format">格式化字符串{0}版本号{1}产品版本号{2}编译日期</param>
            <returns>默认格式 v1.0.0.0 alpha0 build 20181100</returns>
        </member>
        <member name="T:Yunzhi.Common.CommandLineArguments">
            <summary>
            命令行参数解析器
            </summary>
        </member>
        <member name="P:Yunzhi.Common.CommandLineArguments.IgnoreCase">
            <summary>
            获取或设置是否忽略参数大小写
            </summary>
        </member>
        <member name="P:Yunzhi.Common.CommandLineArguments.Arguments">
            <summary>
            获取或设置获取参数的键值对形式
            </summary>
        </member>
        <member name="P:Yunzhi.Common.CommandLineArguments.Item(System.String)">
            <summary>
            获取指定名称参数
            </summary>
        </member>
        <member name="M:Yunzhi.Common.CommandLineArguments.#ctor(System.String[],System.Boolean)">
            <summary>
            初始化命令行参数解决器
            </summary>
            <param name="args">传递原来的原始参数</param>
            <param name="ignoreCase">是否忽略大小写</param>
        </member>
        <member name="M:Yunzhi.Common.CommandLineArguments.IsExists(System.String)">
            <summary>
            检查是否传递过来<paramref name="name"/>指示的参数
            </summary>
            <param name="name">参数名称</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.CommandLineArguments.IsExistsNotValue(System.String)">
            <summary>
            检查是否存在<paramref name="name"/>参数，但没有指定值
            </summary>
            <param name="name">参数名称</param>
            <returns></returns>
        </member>
        <!-- Badly formed XML comment ignored for member "M:Yunzhi.Common.CommandLineArguments.AsString(System.String,System.String)" -->
        <member name="M:Yunzhi.Common.CommandLineArguments.AsBoolean(System.String,System.Boolean)">
            <summary>
            将指定参数转换成<see cref="T:System.Boolean"/>类型
            </summary>
            <param name="name">参数名称</param>
            <param name="defaultValue">默认值</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.CommandLineArguments.AsInt(System.String,System.Int32)">
            <summary>
            将指定参数转换成<see cref="T:System.Int32"/>类型
            </summary>
            <param name="name">参数名称</param>
            <param name="defaultValue">默认值</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Common.DataAnnotations.BankCardAttribute">
            <summary>
            中国大陆银行卡数据校验特性
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.BankCardAttribute.#ctor">
            <summary>
            初始化银行卡验证
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.BankCardAttribute.IsValid(System.Object)">
            <summary>
            确定对象的指定值是否有效
            </summary>
            <param name="value">拉受验证的值对象</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Common.DataAnnotations.CardIdAttribute">
            <summary>
            身份证号数据验证特性
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.CardIdAttribute.#ctor">
            <summary>
            初始化特性
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.CardIdAttribute.IsValid(System.Object)">
            <summary>
            确定对象的指定值是否有效
            </summary>
            <param name="value">拉受验证的值对象</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Common.DataAnnotations.DecimalAttribute">
            <summary>
            小数验证特性
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.DecimalAttribute.#ctor(System.UInt16)">
            <summary>
            初始化特性
            </summary>
            <param name="precision">小数精度</param>
        </member>
        <member name="P:Yunzhi.Common.DataAnnotations.DecimalAttribute.Precision">
            <summary>
            获取或设置要求的小数精度，小于等于此将通过
            </summary>
        </member>
        <member name="P:Yunzhi.Common.DataAnnotations.DecimalAttribute.AllowInteger">
            <summary>
            获取或设置是否接受整数
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.DecimalAttribute.IsValid(System.Object)">
            <inheritdoc />
        </member>
        <member name="T:Yunzhi.Common.DataAnnotations.EntityValidator">
            <summary>
            实体验证帮助类
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.EntityValidator.Validate(System.Object,System.Boolean)">
            <summary>
            验证<paramref name="instance"/>中的所有公共属性的<seealso cref="T:System.ComponentModel.DataAnnotations.ValidationAttribute"/>特性，
            并返回验证不通过的验证消息
            </summary>
            <param name="instance">接受验证的实体实例</param>
            <param name="validateAll">是否验证所有规则，还是在出现第一个验证不能过的规则即返回，以提高性能。</param>
            <returns>成功返回null，否则返回验证结果集。</returns>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.EntityValidator.IsValid(System.Object)">
            <summary>
            验证<paramref name="instance"/>中的所有公共属性，的<seealso cref="T:System.ComponentModel.DataAnnotations.ValidationAttribute"/>特性是否都测试通过
            </summary>
            <param name="instance">要验证的实例</param>
            <returns>true是;false否</returns>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.EntityValidator.GetValidations``1">
            <summary>
            获取指定实体类型的所有验证规则
            </summary>
            <typeparam name="T">实体类型</typeparam>
            <returns>所有公共属性名为键的验证规则</returns>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.EntityValidator.GetValidations(System.Type)">
            <summary>
            获取指定实体类型的所有验证规则
            </summary>
            <param name="type">实体类型</param>
            <returns>所有公共属性名为键的验证规则</returns>
        </member>
        <member name="T:Yunzhi.Common.DataAnnotations.Extends">
            <summary>
            模型数据验证特性的扩展
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.Extends.IsValid(System.ComponentModel.DataAnnotations.ValidationAttribute,System.Object,System.String)">
            <summary>
            确定对象的指定值针对当前验证规则是否有效
            </summary>
            <param name="validation">当前验证特性实例。</param>
            <param name="value">接受验证的值。</param>
            <param name="errorMessage">如果验证失败的错误消息，如果为空则即验证特性的ErrorMessage。</param>
            <returns>通过为null；否则为验证结果实例。</returns>
        </member>
        <member name="T:Yunzhi.Common.DataAnnotations.FixedTelAttribute">
            <summary>
            固定电话号码格式数据验证特性
            </summary>
            <remarks>区号允许有或无-分隔，分机号必须有-分隔，位数不限</remarks>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.FixedTelAttribute.#ctor">
            <summary>
            初始化特性
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.FixedTelAttribute.IsValid(System.Object)">
            <summary>
            确定对象的指定值是否有效
            </summary>
            <param name="value">拉受验证的值对象</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Common.DataAnnotations.MobileAttribute">
            <summary>
            手机号码数据验证特性
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.MobileAttribute.#ctor">
            <summary>
            初始化特性
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.MobileAttribute.IsValid(System.Object)">
            <summary>
            确定对象的指定值是否有效
            </summary>
            <param name="value">拉受验证的值对象</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Common.DataAnnotations.TelAttribute">
            <summary>
            电话号码（手机或固话）数据验证特性
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.TelAttribute.#ctor">
            <summary>
            初始化特性
            </summary>
        </member>
        <member name="M:Yunzhi.Common.DataAnnotations.TelAttribute.IsValid(System.Object)">
            <summary>
            确定对象的指定值是否有效
            </summary>
            <param name="value">拉受验证的值对象</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Common.DataAnnotations.ValidationMessage">
            <summary>
            数据验证消息
            </summary>
        </member>
        <member name="P:Yunzhi.Common.DataAnnotations.ValidationMessage.PropertyName">
            <summary>
            获取或设置验证失败属性名称。
            </summary>
        </member>
        <member name="P:Yunzhi.Common.DataAnnotations.ValidationMessage.Message">
            <summary>
            获取或设置验证不通过错误提示消息。
            </summary>
        </member>
        <member name="T:Yunzhi.Common.DateInterval">
            <summary>
            表示日期间隔类型
            </summary>
        </member>
        <member name="F:Yunzhi.Common.DateInterval.Year">
            <summary>
            年
            </summary>
        </member>
        <member name="F:Yunzhi.Common.DateInterval.Month">
            <summary>
            月
            </summary>
        </member>
        <member name="F:Yunzhi.Common.DateInterval.Week">
            <summary>
            周
            </summary>
        </member>
        <member name="F:Yunzhi.Common.DateInterval.Day">
            <summary>
            天
            </summary>
        </member>
        <member name="T:Yunzhi.Common.Extensions">
            <summary>
            运行时扩展类
            </summary>
        </member>
        <member name="M:Yunzhi.Common.Extensions.IfNoExistsAdd``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1)">
            <summary>
            如果字典中不存相应的键，则添加
            </summary>
            <typeparam name="TKey">字典中的键的类型</typeparam>
            <typeparam name="TValue">字典中的值的类型</typeparam>
            <param name="self">字典实例</param>
            <param name="key">字典键</param>
            <param name="value">字典值</param>
        </member>
        <member name="M:Yunzhi.Common.Extensions.AddOrSet``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1)">
            <summary>
            添加或者设置字典值，如果<paramref name="key"/>存在于字典则修改值，否则添加。
            </summary>
            <typeparam name="TKey">字典中的键的类型</typeparam>
            <typeparam name="TValue">字典中的值的类型</typeparam>
            <param name="self">字典实例</param>
            <param name="key">字典键</param>
            <param name="value">字典值</param>
        </member>
        <member name="M:Yunzhi.Common.Extensions.GetOrDefault``2(System.Collections.Generic.IDictionary{``0,``1},``0,``1)">
            <summary>
            如果字典如果存在
            </summary>
            <typeparam name="TKey">字典中的键的类型</typeparam>
            <typeparam name="TValue">字典中的值的类型</typeparam>
            <param name="self">字典实例</param>
            <param name="key">字典键</param>
            <param name="defaultVal">默认值</param>
        </member>
        <member name="M:Yunzhi.Common.Extensions.RemoveIfExists``2(System.Collections.Generic.IDictionary{``0,``1},``0)">
            <summary>
            字典中如果存在指定键则删除
            </summary>
            <typeparam name="TKey">字典中的键的类型</typeparam>
            <typeparam name="TValue">字典中的值的类型</typeparam>
            <param name="self">字典实例</param>
            <param name="key">要删除的键</param>
        </member>
        <member name="T:Yunzhi.Common.Feedback">
            <summary>
            表示调用执行结果反馈
            </summary>
            <remarks>如果执行添加增删改订单操作响应。</remarks>
        </member>
        <member name="P:Yunzhi.Common.Feedback.Success">
            <summary>
            获取或设置本次调用是否成功执行。
            </summary>
        </member>
        <member name="P:Yunzhi.Common.Feedback.Code">
            <summary>
            获取或设置本次调用返回的响应代码。
            </summary>
        </member>
        <member name="P:Yunzhi.Common.Feedback.Message">
            <summary>
            获取或设置本次调用响应的结果说明消息。
            </summary>
        </member>
        <member name="P:Yunzhi.Common.Feedback.Result">
            <summary>
            获取或设置本次调用响应的结果数据。
            </summary>
        </member>
        <member name="M:Yunzhi.Common.Feedback.#ctor(System.Boolean,System.String,System.Int32,System.Object)">
            <summary>
            初始化执行结果反馈
            </summary>
            <param name="success">操作是否成功完成</param>
            <param name="message">操作反馈消息</param>
            <param name="code">操作响应代码</param>
            <param name="result">操作反馈结果</param>
        </member>
        <member name="M:Yunzhi.Common.Feedback.Error(System.String,System.Int32)">
            <summary>
            创建一个应用发生异常的执行结果反馈
            </summary>
            <param name="msg">异常响应消息，为空是默认响应“发生未知异常，请查看错误日志。”</param>
            <param name="code">响应代码</param>
            <returns>新的执行结果反馈实例</returns>
            <remarks>一般用于调用捕获了异常的中响应结果</remarks>
        </member>
        <member name="M:Yunzhi.Common.Feedback.Ok(System.String,System.Int32,System.Object)">
            <summary>
            创建一个调用成功的执行结果反馈
            </summary>
            <param name="msg">响应消息，为空是默认响应“恭喜，执行成功。”</param>
            <param name="code">响应代码</param>
            <param name="result">响应结果数据</param>
            <returns>新的执行结果反馈实例</returns>
        </member>
        <member name="M:Yunzhi.Common.Feedback.Ok(System.String,System.Object)">
            <summary>
            创建一个调用成功的执行结果反馈
            </summary>
            <param name="msg">响应消息，为空是默认响应“恭喜，执行成功。”</param>
            <param name="result">响应结果数据</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.Feedback.Failure(System.String,System.Int32,System.Object)">
            <summary>
            创建一个调用失败的执行结果反馈
            </summary>
            <param name="msg">异常响应消息，为空是默认响应“抱歉，执行失败。”</param>
            <param name="code">响应代码</param>
            <param name="result">响应结果数据</param>
            <returns>新的执行结果反馈实例</returns>
        </member>
        <member name="M:Yunzhi.Common.Feedback.Failure(System.String,System.Object)">
            <summary>
            创建一个调用失败的执行结果反馈
            </summary>
            <param name="msg">异常响应消息，为空是默认响应“抱歉，执行失败。”</param>
            <param name="result">响应结果数据</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Common.Feedback`1">
            <summary>
            表示一个可携带指定结果数据类型的调用执行结果反馈
            </summary>
            <typeparam name="T">指示<see cref="P:Yunzhi.Common.Feedback`1.Result"/>的类型</typeparam>
        </member>
        <member name="P:Yunzhi.Common.Feedback`1.Result">
            <summary>
            获取或设置本次调用响应的结果数据。
            </summary>
        </member>
        <member name="M:Yunzhi.Common.Feedback`1.#ctor(System.Boolean,System.String,System.Int32,`0)">
            <summary>
            初始化执行结果反馈
            </summary>
            <param name="success">操作是否成功完成</param>
            <param name="message">操作反馈消息</param>
            <param name="code">操作响应代码</param>
            <param name="result">操作反馈结果</param>
        </member>
        <member name="M:Yunzhi.Common.Feedback`1.Error(System.String,System.Int32)">
            <summary>
            创建一个应用发生异常的执行结果反馈
            </summary>
            <param name="msg">异常响应消息，为空是默认响应“发生未知异常，请查看错误日志。”</param>
            <param name="code">响应代码</param>
            <returns>新的执行结果反馈实例</returns>
            <remarks>一般用于调用捕获了异常的中响应结果</remarks>
        </member>
        <member name="M:Yunzhi.Common.Feedback`1.Ok(System.String,System.Int32,`0)">
            <summary>
            创建一个调用成功的执行结果反馈
            </summary>
            <param name="msg">异常响应消息，为空是默认响应“恭喜，执行成功。”</param>
            <param name="code">响应代码</param>
            <param name="result">响应结果数据</param>
            <returns>新的执行结果反馈实例</returns>
        </member>
        <member name="M:Yunzhi.Common.Feedback`1.Ok(System.String,`0)">
            <summary>
            创建一个调用成功的执行结果反馈
            </summary>
            <param name="msg">异常响应消息，为空是默认响应“恭喜，执行成功。”</param>
            <param name="result">响应结果数据</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.Feedback`1.Failure(System.String,System.Int32,`0)">
            <summary>
            创建一个调用失败的执行结果反馈
            </summary>
            <param name="msg">异常响应消息，为空是默认响应“抱歉，执行失败。”</param>
            <param name="code">响应代码</param>
            <param name="result">响应结果数据</param>
            <returns>新的执行结果反馈实例</returns>
        </member>
        <member name="M:Yunzhi.Common.Feedback`1.Failure(System.String,`0)">
            <summary>
            创建一个调用失败的执行结果反馈
            </summary>
            <param name="msg">异常响应消息，为空是默认响应“抱歉，执行失败。”</param>
            <param name="result">响应结果数据</param>
            <returns>新的执行结果反馈实例</returns>
        </member>
        <member name="T:Yunzhi.Common.GisConverter">
            <summary>
            地理坐标转换器
            </summary>
        </member>
        <member name="M:Yunzhi.Common.GisConverter.IsOutOfChina(System.Double,System.Double)">
            <summary>
            判断指定的GPS经纬度是否超出中国大陆范围。
            </summary>
            <param name="longitude">经度值。</param>
            <param name="latitude">纬度值。</param>
            <returns>验证结果。</returns>
        </member>
        <member name="M:Yunzhi.Common.GisConverter.TransformLongitude(System.Double,System.Double)">
            <summary>
            转换GPS经度值。
            </summary>
            <param name="longitude">经度值。</param>
            <param name="latitude">纬度值。</param>
            <returns>转换后的经度值。</returns>
        </member>
        <member name="M:Yunzhi.Common.GisConverter.TransformLatitude(System.Double,System.Double)">
            <summary>
            转换GPS纬度值。
            </summary>
            <param name="longitude">经度值。</param>
            <param name="latitude">纬度值。</param>
            <returns>转换后的纬度值。</returns>
        </member>
        <member name="M:Yunzhi.Common.GisConverter.Wgs84ToGcj02(Yunzhi.Common.GisCoordinate)">
            <summary>
            将世界标准地理坐标(GPS:WGS-84)转换成中国国测局地理坐标(火星:GCJ-02)
            </summary>
            <param name="wgs84">WGS84坐标</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.GisConverter.Gcj02ToWgs84(Yunzhi.Common.GisCoordinate)">
            <summary>
            将中国国测局地理坐标(火星:GCJ-02)转换成世界标准地理坐标(GPS:WGS-84)
            </summary>
            <param name="gcj02">GCJ02坐标</param>
            <returns>WGS-84坐标实例。</returns>
            <remarks>此接口有1-2米左右的误差，需要精确的场景慎用。</remarks>
        </member>
        <member name="M:Yunzhi.Common.GisConverter.Bd09ToGcj02(Yunzhi.Common.GisCoordinate)">
            <summary>
            将百度地理坐标(BD-09)转换成中国国测局地理坐标(火星:GCJ-02)
            </summary>
            <param name="bd09">BD09坐标</param>
            <returns>GCJ-02坐标实例。</returns>
        </member>
        <member name="M:Yunzhi.Common.GisConverter.Gcj02ToBd09(Yunzhi.Common.GisCoordinate)">
            <summary>
            将中国国测局地理坐标(火星:GCJ-02)转换成百度地理坐标(BD-09)
            </summary>
            <param name="gcj02">GCJ-02坐标</param>
            <returns>BD-09坐标实例</returns>
        </member>
        <member name="M:Yunzhi.Common.GisConverter.Wgs84ToBd09(Yunzhi.Common.GisCoordinate)">
            <summary>
            将世界标准地理坐标(GPS:WGS-84)转换成百度地理坐标(BD-09)
            </summary>
            <param name="wgs84">WGS84坐标</param>
            <returns>BD-09坐标实例</returns>
        </member>
        <member name="M:Yunzhi.Common.GisConverter.Bd09ToWgs84(Yunzhi.Common.GisCoordinate)">
            <summary>
            将百度地理坐标(BD-09)转换成世界标准地理坐标(GPS:WGS-84)
            </summary>
            <param name="bd09">BD09坐标</param>
            <returns>WGS84坐标实例</returns>
        </member>
        <member name="T:Yunzhi.Common.GisCoordinate">
            <summary>
            表示一个GIS的地理坐标
            </summary>
        </member>
        <member name="P:Yunzhi.Common.GisCoordinate.Longitude">
            <summary>
            获取或设置坐标经度。
            </summary>
        </member>
        <member name="P:Yunzhi.Common.GisCoordinate.Latitude">
            <summary>
            获取或设置坐标纬度。
            </summary>
        </member>
        <member name="M:Yunzhi.Common.GisCoordinate.#ctor(System.Double,System.Double)">
            <summary>
            初始化地理坐标。
            </summary>
            <param name="longitude">经度</param>
            <param name="latitude">纬度</param>
        </member>
        <member name="M:Yunzhi.Common.GisCoordinate.GetGeoHash(System.Int32)">
            <summary>
            获取当前坐标的GEOHASH值
            </summary>
            <param name="precision">坐标HASH精度</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.GisCoordinate.ToString">
            <summary>
            将GIS坐标转换成<see cref="P:Yunzhi.Common.GisCoordinate.Longitude"/>,<seealso cref="P:Yunzhi.Common.GisCoordinate.Latitude"/>格式
            </summary>
            <returns>字符串</returns>
        </member>
        <member name="T:Yunzhi.Common.GisNearRange">
            <summary>
            表示一个附近的地理范围
            </summary>
        </member>
        <member name="P:Yunzhi.Common.GisNearRange.Location">
            <summary>
            获取或设置原点经纬地理坐标
            </summary>
        </member>
        <member name="P:Yunzhi.Common.GisNearRange.MaxDistance">
            <summary>
            获取或设置最大距离，单位：米
            </summary>
        </member>
        <member name="P:Yunzhi.Common.GisNearRange.MinDistance">
            <summary>
            获取或设置最小距离，单位：米
            </summary>
        </member>
        <member name="T:Yunzhi.Common.LinuxDaemonInstaller">
            <summary>
            Linux（CentOS）服务安装部署器
            </summary>
            <remarks>目前仅在CentOS测试支持</remarks>
        </member>
        <member name="M:Yunzhi.Common.LinuxDaemonInstaller.#ctor">
            <summary>
            初始化安装部署器
            </summary>
        </member>
        <member name="M:Yunzhi.Common.LinuxDaemonInstaller.GetAssemblyAttribute``1">
            <summary>
            获取入口程序集，即主程序集的说明特性
            </summary>
            <typeparam name="T">要获取的自定义特性</typeparam>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.LinuxDaemonInstaller.Welcome">
            <summary>
            输出欢迎信息
            </summary>
        </member>
        <member name="M:Yunzhi.Common.LinuxDaemonInstaller.WriteHead">
            <summary>
            写入声名文件头
            </summary>
        </member>
        <member name="M:Yunzhi.Common.LinuxDaemonInstaller.WriteSummary">
            <summary>
            写入文件头部注释说明
            </summary>
        </member>
        <member name="M:Yunzhi.Common.LinuxDaemonInstaller.WriteUnit">
            <summary>
            写入[Unit]组
            </summary>
        </member>
        <member name="M:Yunzhi.Common.LinuxDaemonInstaller.WriteService">
            <summary>
            写入[Service]节
            </summary>
        </member>
        <member name="M:Yunzhi.Common.LinuxDaemonInstaller.WriteInstall">
            <summary>
            写入[Install]节
            </summary>
        </member>
        <member name="M:Yunzhi.Common.LinuxDaemonInstaller.Deploy">
            <summary>
            部署
            </summary>
        </member>
        <member name="M:Yunzhi.Common.LinuxDaemonInstaller.Install">
            <summary>
            启动安装部署
            </summary>
        </member>
        <member name="T:Yunzhi.Common.PagedData">
            <summary>
            分页数据结果模型
            </summary>
        </member>
        <member name="P:Yunzhi.Common.PagedData.PageIndex">
            <summary>
            获取或设置当前索引页。
            </summary>
        </member>
        <member name="P:Yunzhi.Common.PagedData.PageSize">
            <summary>
            获取或设置分页大小，即每页记录数
            </summary>
        </member>
        <member name="P:Yunzhi.Common.PagedData.RowCount">
            <summary>
            获取或设置记录总数。
            </summary>
        </member>
        <member name="P:Yunzhi.Common.PagedData.PageCount">
            <summary>
            获取或设置总页数
            </summary>
        </member>
        <member name="P:Yunzhi.Common.PagedData.IsLazy">
            <summary>
            获取或设置是否为懒分页模式
            即：不返回<see cref="P:Yunzhi.Common.PagedData.RowCount"/>和<see cref="P:Yunzhi.Common.PagedData.PageCount"/>，直接到加载完成为止
            </summary>
        </member>
        <member name="P:Yunzhi.Common.PagedData.Data">
            <summary>
            获取或设置数据结果集合。
            </summary>
        </member>
        <member name="P:Yunzhi.Common.PagedData.IsLast">
            <summary>
            获取或设置是否已经是最后一页
            </summary>
            <remarks>懒模式是：以<see cref="P:Yunzhi.Common.PagedData.Data"/>是否为空为依据，否则以<see cref="P:Yunzhi.Common.PagedData.PageIndex"/>==<see cref="P:Yunzhi.Common.PagedData.PageCount"/></remarks>
        </member>
        <member name="M:Yunzhi.Common.PagedData.#ctor">
            <summary>
            初始化一个空的分页数据结果模型
            </summary>
        </member>
        <member name="M:Yunzhi.Common.PagedData.#ctor(Yunzhi.Database.Paged,System.Collections.Generic.IEnumerable{System.Object})">
            <summary>
            以分页结果初始化分页结果模型
            </summary>
            <param name="page"></param>
            <param name="data"></param>
        </member>
        <member name="T:Yunzhi.Common.PagedData`1">
            <summary>
            分页数据结果模型
            </summary>
        </member>
        <member name="P:Yunzhi.Common.PagedData`1.Data">
            <summary>
            获取或设置当前页的数据
            </summary>
        </member>
        <member name="M:Yunzhi.Common.PagedData`1.#ctor">
            <summary>
            初始化一个空的分页数据结果模型
            </summary>
        </member>
        <member name="T:Yunzhi.Common.Saber">
            <summary>
            常用的公共工具类方法
            </summary>
        </member>
        <member name="M:Yunzhi.Common.Saber.IsDomain(System.String)">
            <summary>
            验证<paramref name="domainText"/>是否为一个合法的域名
            </summary>
            <param name="domainText">接受验证的域名文本</param>
            <returns>true是;false否</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.IsNumber(System.String)">
            <summary>
            判断<paramref name="numText"/>是否为数字
            </summary>
            <param name="numText">接受判断的数字字符串</param>
            <returns>true是;false否</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.IsIntNumber(System.String)">
            <summary>
             判断<paramref name="numText"/>是否为正整数
            </summary>
            <param name="numText">接受判断的数字字符串</param>
            <returns>true是;false否</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.IsDecimalNumber(System.String,System.UInt16)">
            <summary>
            判断<paramref name="text"/>是否为小数
            </summary>
            <param name="text">接受判断的文本</param>
            <param name="precision">小数精度，即小数位数，小于等于此精度通过，不能小于1</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.IsDate(System.String)">
            <summary>
            判断<paramref name="dateText"/>是否为日期
            </summary>
            <param name="dateText">要判断的字符串</param>
            <returns>true是;false否</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.IsEmail(System.String)">
            <summary>
            判断<paramref name="email"/>是否为E-Mail地址
            </summary>
            <param name="email">接受验证的E-Mail地址</param>
            <returns>true是;false否</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.IsUrl(System.String)">
            <summary>
            判断<paramref name="url"/>是否一个正确的http[s]URL地址
            </summary>
            <param name="url">接受判断的URL字符串</param>
            <returns>true是;false否</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.IsBankNumber(System.String)">
            <summary>
            验证<paramref name="cardNo"/>是否为一个标准的大陆银行卡号
            </summary>
            <param name="cardNo">接受验证的字符串</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.IsMobileNumber(System.String)">
            <summary>
            验证<paramref name="number"/>是否一个合法的手机号码
            </summary>
            <param name="number">接受验证的号码</param>
            <returns>true是;false否</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.IsFixedTelNumber(System.String)">
            <summary>
            验证<paramref name="number"/>是否一个合法的固定手机号码
            </summary>
            <param name="number">接受验证的号码</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.MaskPrivacy(System.String,System.Int32,System.Nullable{System.Int32})">
            <summary>
            对<paramref name="text"/>进行脱敏掩处理，比如13866668888转换成138****8888
            </summary>
            <param name="text">要脱敏的文本</param>
            <param name="len">脱敏的长度，即对多少进行掩码处理</param>
            <param name="start">开始进行掩码的位置，不指定则取中间位置</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.Is18CardId(System.String)">
            <summary>
            判断<paramref name="cardId"/>是否合法的18位身份证号码
            </summary>
            <param name="cardId">接受校验身份证号码</param>
            <returns>true是；false否</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.Is18CardId(System.String,System.Boolean)">
            <summary>
            判断<paramref name="cardId"/>是否为合法的18位身份证号码，
            并且与<paramref name="sex"/>指示的性别相匹配
            </summary>
            <param name="cardId">接受校验身份证号码</param>
            <param name="sex">性别，true男、false女</param>
            <returns>true是；false否</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.GetCardBirth(System.String)">
            <summary>
            如果<paramref name="cardId"/>为合法的18位身份证号码
            则从身份证号码提取出生年月
            </summary>
            <param name="cardId">接受提取的身份证号码</param>
            <returns>合法返回出生年月，否则返回null</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.GetCardSex(System.String)">
            <summary>
            如果<paramref name="cardId"/>为合法的18位身份证号码
            则从中提取性别
            </summary>
            <param name="cardId">接受提取的身份证号码</param>
            <returns>合法返回性别[true男,false女]；否则返回null</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.GetAbsPath(System.String,System.String)">
            <summary>
            以<paramref name="currentPath"/>为当前路径，计算相对路径<paramref name="relativePath"/>的绝对路径。
            </summary>
            <param name="currentPath">当前路径</param>
            <param name="relativePath">要计算的相对路径</param>
            <returns>转换后的绝对路径</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.GetAbsPath(System.String)">
            <summary>
            以<seealso cref="T:System.AppDomain"/>的BaseDirectory为当前目录计算<paramref name="relativePath"/>指示的相对路径的绝对路径。
            </summary>
            <param name="relativePath">要计算的相对路径</param>
            <returns>转换后的绝对路径</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.ToEnum``1(System.String)">
            <summary>
            将指定的枚举名称转换相应的枚举
            </summary>
            <typeparam name="T">要转换枚举类型</typeparam>
            <param name="name">枚举名称</param>
            <returns>转换成功的枚举</returns>
        </member>
        <!-- Badly formed XML comment ignored for member "M:Yunzhi.Common.Saber.GetDescription(System.Enum,System.String)" -->
        <member name="M:Yunzhi.Common.Saber.DateDifference(System.DateTime,System.DateTime,Yunzhi.Common.DateInterval,System.Boolean)">
            <summary>
            计算两个日期之间经历了多少指定的时间间隔
            </summary>
            <param name="beginDate">起始日期</param>
            <param name="endDate">截止日期</param>
            <param name="interval">间隔类型</param>
            <param name="ignoreTime">是否忽略日期的时间部分</param>
            <returns>间隔数</returns>
            <remarks>只返回间隔数的整数部分，小数部分将被忽略</remarks>
        </member>
        <member name="M:Yunzhi.Common.Saber.Timestamp">
            <summary>
            以前当系统时间，生成时间戳
            </summary>
            <returns>
            UNIX时间戳，时区采用UTC时区。 
            </returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.Timestamp(System.DateTime)">
            <summary>
            以前指定时间，生成时间戳
            </summary>
            <returns>
            UNIX时间戳，时区采用UTC时区。 
            </returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.Timestamp(System.Int64)">
            <summary>
            将时间戳转换成相应的时间
            </summary>
            <param name="seconds">秒数时间戳，标准的UNIX时间戳，时区以UTC时区</param>
            <returns>转换时采用UTC转换，返回值为本系统时间戳</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.GeoHash(System.Double,System.Double,System.Int32)">
            <summary>
            计算经纬度坐标的的HASH值
            </summary>
            <param name="latitude">纬度</param>
            <param name="longitude">经度</param>
            <param name="precision">需要生成的HASH精度位数</param>
            <returns>标准的GeoHash算法</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.Distance(Yunzhi.Common.GisCoordinate,Yunzhi.Common.GisCoordinate)">
            <summary>
            计算两个地图坐标之间的距离。
            </summary>
            <param name="start">起始坐标</param>
            <param name="end">终点坐标</param>
            <returns>两点之间的距离，单位M</returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.Distance(System.Double,System.Double,System.Double,System.Double)">
            <summary>
            计算两个地图坐标之间的距离
            </summary>
            <param name="startLongitude">起始坐标经度</param>
            <param name="startLatitude">起始坐标纬度</param>
            <param name="endLongitude">终点坐标经度</param>
            <param name="endLatitude">起始坐标纬度</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.Saber.RandCnChars(System.UInt16)">
            <summary>
            生成随机汉字字符串
            </summary>
            <param name="length">生成的长度</param>
            <returns></returns>
            <remarks>
            生成编码采用GB2312国标
            </remarks>
        </member>
        <member name="T:Yunzhi.Common.Terminals">
            <summary>
            提供字符终端的<see cref="T:System.Console"/>的一些快捷操作员
            </summary>
        </member>
        <member name="M:Yunzhi.Common.Terminals.formatException(System.Exception,System.Text.StringBuilder)">
            <summary>
            格式化异常输出
            </summary>
            <param name="exception">要输出的异常</param>
            <param name="build">循环输出的错误文本</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Common.Terminals.Write(System.String,System.ConsoleColor)">
            <summary>
            输出一条带颜色的文字
            </summary>
            <param name="message">要输入的消息</param>
            <param name="color">文字颜色</param>
        </member>
        <member name="M:Yunzhi.Common.Terminals.WriteLine(System.String,System.ConsoleColor)">
            <summary>
            输出一行带颜色的文字
            </summary>
            <param name="message"></param>
            <param name="color"></param>
        </member>
        <member name="M:Yunzhi.Common.Terminals.Info(System.String)">
            <summary>
            输入一条绿色的成功消息
            </summary>
            <param name="message">要输出的消息</param>
        </member>
        <member name="M:Yunzhi.Common.Terminals.Warning(System.String)">
            <summary>
            输出一条黄色警告消息
            </summary>
            <param name="message">要输出的消息</param>
        </member>
        <member name="M:Yunzhi.Common.Terminals.Error(System.String)">
            <summary>
            输出一条红色警告消息
            </summary>
            <param name="message">要输出的消息</param>
        </member>
        <member name="M:Yunzhi.Common.Terminals.Error(System.Exception)">
            <summary>
            输入一条异常消息
            </summary>
            <param name="ex"></param>
        </member>
        <member name="T:Yunzhi.Common.ZipSaber">
            <summary>
            ZIP压缩、解压相关工具方法
            </summary>
        </member>
        <member name="M:Yunzhi.Common.ZipSaber.zipAppendFiles(System.String,System.String,System.IO.Compression.ZipArchive,System.IO.Compression.CompressionLevel,System.Func{System.IO.FileInfo,System.Boolean})">
            <summary>
            往压缩文件里添加目录
            </summary>
            <param name="rootPath">创建压压缩包的根目录，进行相地路径计算</param>
            <param name="destPath">要加入的目标文件夹</param>
            <param name="zip">压缩包</param>
            <param name="level">压缩级别</param>
            <param name="filter">文件筛选器</param>
        </member>
        <member name="M:Yunzhi.Common.ZipSaber.ZipDirectory(System.String,System.String,System.Func{System.IO.FileInfo,System.Boolean},System.IO.Compression.CompressionLevel)">
            <summary>
            以ZIP形式压缩目录
            </summary>
            <param name="source">要压缩的文件夹路径</param>
            <param name="zipFileName">压缩的目标文件名</param>
            <param name="filter">文件过滤筛选，返回true压缩,false不压缩</param>
            <param name="level">压缩级别</param>
        </member>
        <member name="M:Yunzhi.Common.ZipSaber.UnZipDirectory(System.String,System.String,System.Func{System.IO.Compression.ZipArchiveEntry,System.Boolean})">
            <summary>
            解压ZIP压缩包到指定目录
            </summary>
            <param name="zipFileName">zip压缩包文件名</param>
            <param name="destPath">目标文件夹</param>
            <param name="filter">解压过滤，true解压;false不解压</param>
        </member>
        <member name="T:Yunzhi.Configuration.ParameterCollection">
            <summary>
            自定义可选参数键值对集合
            </summary>
            <remarks>字典键不区分大小写</remarks>
        </member>
        <member name="M:Yunzhi.Configuration.ParameterCollection.Add(System.String,System.String)">
            <summary>
            添加一个字典参数
            </summary>
            <param name="key">参数唯一键</param>
            <param name="value">参数值</param>
        </member>
        <member name="M:Yunzhi.Configuration.ParameterCollection.Add(System.Collections.Generic.KeyValuePair{System.String,System.String})">
            <summary>
            添加一个字典参数
            </summary>
            <param name="item">要添加的参数</param>
        </member>
        <member name="M:Yunzhi.Configuration.ParameterCollection.ContainsKey(System.String)">
            <summary>
            确认<paramref name="key"/>指定的键是否已经在字典中存在
            </summary>
            <param name="key">字典键</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Configuration.ParameterCollection.GetValue(System.String,System.String)">
            <summary>
            获取指定Key的参数值
            </summary>
            <param name="key">配置参数key</param>
            <param name="defaultValue">如果没有寻找到配置参数的默认值</param>
            <returns>如果存在返回配置值；否则返回<paramref name="defaultValue"/>默认值。</returns>
        </member>
        <member name="M:Yunzhi.Configuration.ParameterCollection.GetValue``1(System.String)">
            <summary>
            获取指定Key值，并转换成T指示的类型
            </summary>
            <typeparam name="T">要转换的目标类型</typeparam>
            <param name="key">配置参数key</param>
            <returns>转换后的目录类型，或者为空时该类型默认值</returns>
        </member>
        <member name="M:Yunzhi.Configuration.ParameterCollection.GetValue``1(System.String,``0)">
            <summary>
            获取指定Key值，并转换成T指示的类型
            </summary>
            <typeparam name="T">要转换的目标类型</typeparam>
            <param name="key">配置参数key</param>
            <param name="defaultValue">默认值</param>
            <returns>转换后的目录类型，或者为空时返回<paramref name="defaultValue"/></returns>
        </member>
        <member name="T:Yunzhi.Configuration.ParameterElement">
            <summary>
            表示一个可选参数配置元素
            </summary>
        </member>
        <member name="P:Yunzhi.Configuration.ParameterElement.Key">
            <summary>
            获取或设置表示配置键
            </summary>
        </member>
        <member name="P:Yunzhi.Configuration.ParameterElement.Value">
            <summary>
            获取或设置表示配置值
            </summary>
        </member>
        <member name="T:Yunzhi.Configuration.YunzhiAppConfiguration">
            <summary>
            云智应用配置文件管理入口
            </summary>
        </member>
        <member name="P:Yunzhi.Configuration.YunzhiAppConfiguration.Current">
            <summary>
            获取当前应用配置
            </summary>
        </member>
        <member name="P:Yunzhi.Configuration.YunzhiAppConfiguration.AppSettings">
            <summary>
            获取公共应用参数配置
            路径yunzhi:appSettings
            </summary>
        </member>
        <member name="M:Yunzhi.Configuration.YunzhiAppConfiguration.Injection(Microsoft.Extensions.Configuration.IConfiguration)">
            <summary>
            设置当前应用配置
            </summary>
            <param name="config">配置</param>
        </member>
        <member name="M:Yunzhi.Configuration.YunzhiAppConfiguration.Bind``1">
            <summary>
            快速绑定获取配置节
            <seealso cref="M:Microsoft.Extensions.Configuration.ConfigurationBinder.Bind(Microsoft.Extensions.Configuration.IConfiguration,System.Object)"/>的快捷方法
            </summary>
            <typeparam name="T">配置节类型</typeparam>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Configuration.YunzhiAppConfiguration.Bind``1(System.String)">
            <summary>
            快速绑定获取配置节
            <seealso cref="M:Microsoft.Extensions.Configuration.ConfigurationBinder.Bind(Microsoft.Extensions.Configuration.IConfiguration,System.String,System.Object)"/>的快捷方法
            </summary>
            <typeparam name="T">配置节类型</typeparam>
            <param name="path">配置路径，如yunzhi:cache</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Configuration.YunzhiAppConfiguration.GetConnectionString(System.String)">
            <summary>
            获取当前配置的连接字符串
            </summary>
            <param name="name">连接字符串名称</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Configuration.YunzhiAppConfiguration.AddYunzhiAppJsonConfigFile(Microsoft.Extensions.Configuration.IConfigurationBuilder)">
            <summary>
            为应用配置构造器增加云智配置默认JSON配置文件
            </summary>
            <param name="builder">当前配置构造器实例</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Database.DataSaber">
            <summary>
            跟数据处理相关的工具方法
            </summary>
        </member>
        <member name="M:Yunzhi.Database.DataSaber.ExportWithHTML(System.Data.DataTable,System.Collections.Generic.IEnumerable{System.String})">
            <summary>
            以HTML，Table将Datatable数据导出
            </summary>
            <param name="table">要导出的表</param>
            <param name="fieldsDescriprt">&lt;ColumnName,Descipt[,#String|#Datetime]&gt; 字段格式描述集合</param>
            <returns>生成的HTML</returns>
            
        </member>
        <member name="M:Yunzhi.Database.DataSaber.ExportWithHTML(System.Data.DataTable,System.Collections.Generic.IEnumerable{System.String},System.Boolean)">
            <summary>
            以HTML的形式生成导出
            </summary>
            <param name="table">要导出的表</param>
            <param name="fieldsDescript">&lt;ColumnName,Descipt[,#String|#Datetime]&gt; 以此格式的字段说明</param>
            <param name="outNotField">
            true输出<paramref name="fieldsDescript"/>未包含的列;
            false不输出<paramref name="fieldsDescript"/>不包含的列
            </param>
            <returns>生成的HTML</returns>
        </member>
        <member name="M:Yunzhi.Database.DataSaber.ExportCSV(System.Data.DataTable,System.Collections.Generic.IEnumerable{System.String})">
            <summary>
            的形式生成导出
            </summary>
            <param name="table">要导出的表</param>
            <param name="fieldsDescript">&lt;ColumnName,Descipt[,#String|#Datetime]&gt; 以此格式的字段说明</param>
            <returns>生成的HTML</returns>
        </member>
        <member name="M:Yunzhi.Database.DataSaber.ExportCSV(System.Data.DataTable,System.Collections.Generic.IEnumerable{System.String},System.Boolean)">
            <summary>
            的形式生成导出
            </summary>
            <param name="table">要导出的表</param>
            <param name="fieldsDescript">&lt;ColumnName,Descipt[,#String|#Datetime]&gt; 以此格式的字段说明</param>
            <param name="outNotField">
            true输出<paramref name="fieldsDescript"/>未包含的列;
            false不输出<paramref name="fieldsDescript"/>不包含的列
            </param>
            <returns>生成的HTML</returns>
        </member>
        <member name="M:Yunzhi.Database.DataSaber.parseCall(System.Type)">
            <summary>
            检测<paramref name="type"/>是否具有Parse(string)方法
            </summary>
            <param name="type">接受检测的类型</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Database.DataSaber.toValue``1(System.Object)">
            <summary>
            动态值类型转换
            </summary>
            <typeparam name="T">要转换的目标类型</typeparam>
            <param name="value">要转换的值</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Database.DataSaber.FirstTable(System.Data.DataSet)">
            <summary>
            获取当前数据集中第一张表
            </summary>
            <param name="dataset">当前数据集实例</param>
            <returns>如果存在表返回第一张；否则返回Null</returns>
        </member>
        <member name="M:Yunzhi.Database.DataSaber.HasRows(System.Data.DataTable)">
            <summary>
            确认当前DataTable是否有记录
            </summary>
            <param name="datatable">DataTable实例</param>
            <returns>true存在;false不存在</returns>
        </member>
        <member name="M:Yunzhi.Database.DataSaber.ToValue``1(System.Data.DataRow,System.String)">
            <summary>
            将当前行指定列的值解析成<typeparamref name="T"/>指示的类型
            </summary>
            <typeparam name="T">要转换的目标类型</typeparam>
            <param name="datarow">当前行记录实例</param>
            <param name="column">要转换的列名</param>
            <returns>如果为DBNull转换成T的默值，否则强转换相应的类型</returns>
        </member>
        <member name="M:Yunzhi.Database.DataSaber.ToValue``1(System.Data.DataRow,System.Int32)">
            <summary>
            将当前行指定列的值解析成<typeparamref name="T"/>指示的类型
            </summary>
            <typeparam name="T">要转换的目标类型</typeparam>
            <param name="datarow">当前行记录实例</param>
            <param name="index">要转换列的索引</param>
            <returns>如果为DBNull转换成T的默值，否则强转换相应的类型</returns>
        </member>
        <member name="M:Yunzhi.Database.DataSaber.ToValue``1(System.Data.DataTable,System.Int32,System.String)">
            <summary>
            将指定行指定列的值解析成<typeparamref name="T"/>指示的类型
            </summary>
            <typeparam name="T">要转换的目标类型</typeparam>
            <param name="datatab">当前表实例</param>
            <param name="rowIndex">行记录索引</param>
            <param name="columnName">要转换列名称</param>
            <returns>如果为DBNull转换成T的默值，否则强转换相应的类型</returns>
        </member>
        <member name="M:Yunzhi.Database.DataSaber.ToValue``1(System.Data.DataTable,System.Int32,System.Int32)">
            <summary>
            将指定行指定列的值解析成<typeparamref name="T"/>指示的类型
            </summary>
            <typeparam name="T">要转换的目标类型</typeparam>
            <param name="datatab">当前表实例</param>
            <param name="rowIndex">行记录索引</param>
            <param name="columnIndex">要转换列的索引</param>
            <returns>如果为DBNull转换成T的默值，否则强转换相应的类型</returns>
        </member>
        <member name="T:Yunzhi.Database.DbAccessAdapterBase">
            <summary>
            关系数据库产品的访问适配器基类，实现基本操作
            </summary>
        </member>
        <member name="P:Yunzhi.Database.DbAccessAdapterBase.Connection">
            <summary>
            获取或者设置当前数据库连接
            </summary>
        </member>
        <member name="P:Yunzhi.Database.DbAccessAdapterBase.IsTransaction">
            <summary>
            获取当前是否指示要求接下来语句以事务形式提交
            </summary>
            <remarks>为true表示已经提示要求执行事务，但是未执行Commit()或者Rollback()</remarks>
        </member>
        <member name="P:Yunzhi.Database.DbAccessAdapterBase.Syntax">
            <summary>
            获取或设置抽象Sql语法解析器
            </summary>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.Create(Yunzhi.Database.SqlProduct)">
            <summary>
            创建指定数据产品的默认访问适配器。
            </summary>
            <param name="product">要创的创建的数据产品</param>
            <returns>已经适返回实例，否则返回null.</returns>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.#cctor">
            <summary>
            初始化配置
            </summary>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.Open">
            <summary>
            打开当前数据库连接
            </summary>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.Close">
            <summary>
            关闭当前数据库连接
            </summary>
            <remarks>有事务未提交时，连接不会被关闭，除非先回滚或者提交事务。</remarks>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.RunSqlCommand(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行Sql语句，但不返回值
            </summary>
            <param name="sqlCommand">要执行的Sql语句</param>
            <param name="parameters">Sql语所需的参数</param>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.RunSqlCommand(Yunzhi.Database.SqlStatement.Sql,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行Sql语句，但不返回值
            </summary>
            <param name="sqlStatement">要执行的抽象Sql语句</param>
            <param name="parameters">Sql语所需的参数</param>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.Select(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter},Yunzhi.Database.Paged)">
            <summary>
            执行SELECT语句并且返回查询结果
            </summary>
            <param name="sqlCommand">要执行的SELECT语句</param>
            <param name="parameters">SELECT语句所需要的参数</param>
            <param name="paged">分页设置和结果</param>
            <returns>查询的结果</returns>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.Select(Yunzhi.Database.SqlStatement.SelectStatement,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter},Yunzhi.Database.Paged)">
            <summary>
            执行SELECT语句并且返回查询结果
            </summary>
            <param name="sqlStatement">要执行的SELECT语句</param>
            <param name="parameters">SELECT语句所需要的参数</param>
            <param name="paged">分页设置和结果</param>
            <returns>查询的结果</returns>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.ExecProcedure(System.String,System.Data.SqlDbType,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行SQL语句，并返回执行返回值
            </summary>
            <param name="procedure">存储过程名称</param>
            <param name="dbType">返回值数据类型</param>
            <param name="parameters">存储过程参数</param>
            <returns>存储过程返回值（非输入参数)</returns>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.ExecProcedureToDs(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行SQL语句，并返回一个<seealso cref="T:System.Data.DataSet"/>
            </summary>
            <param name="procedure">存储过程名称</param>
            <param name="parameters">存储过程参数</param>
            <returns>返回填充好的DataSet</returns>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.BeginTransaction(System.Nullable{System.Data.IsolationLevel})">
            <summary>
            指示从现在开始本实例提交的所有Sql以事务形式执行，直到执行Commit或者Rollback方法
            </summary>
            <param name="level">指示事务的ISO锁定级别，不指定以库默认</param>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.Commit">
            <summary>
            提交当前执行的事务
            </summary>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.Rollback">
            <summary>
            回滚当前提交的事务
            </summary>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.DebugLogTrack(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            输出日志SQL语句跟踪
            </summary>
            <param name="sql">执行的SQL语句</param>
            <param name="parameters">SQL语句参数</param>
            <remarks>只有配置了名为debug的日志记录器才输出</remarks>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.DebugTrack(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            调试跟踪SQL语句
            </summary>
            <param name="sql">执行的SQL语句</param>
            <param name="parameters">SQL语句参数</param>
        </member>
        <member name="M:Yunzhi.Database.DbAccessAdapterBase.Dispose">
            <summary>
            释放连接资源
            </summary>
        </member>
        <member name="T:Yunzhi.Database.Extensions">
            <summary>
            一些扩展工具方法
            </summary>
        </member>
        <member name="M:Yunzhi.Database.Extensions.WhereIfTrue``1(System.Linq.IQueryable{``0},System.Boolean,System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})">
            <summary>
            根据给定的决断条件<paramref name="resolve"/>决定时是否执行<paramref name="predicate"/>的筛选
            </summary>
            <typeparam name="T">查询实体类型</typeparam>
            <param name="queryable">要执行筛选的<seealso cref="T:System.Linq.IQueryable`1"/></param>
            <param name="resolve">决断表达式，true才会执行<paramref name="predicate"/>筛选，false不执行 </param>
            <param name="predicate">筛选表达式</param>
            <returns>
            <paramref name="resolve"/>为true,返回新的<seealso cref="T:System.Collections.Generic.IEnumerator`1"/>
            否则返回<paramref name="queryable"/>
            </returns>
        </member>
        <member name="M:Yunzhi.Database.Extensions.WhereIfTrue``1(System.Linq.IQueryable{``0},System.String,System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})">
            <summary>
            如果<paramref name="searchText"/>不为空，则执行<paramref name="predicate"/>的筛选
            </summary>
            <typeparam name="T">查询实体类型</typeparam>
            <param name="queryable">要执行筛选的<seealso cref="T:System.Linq.IQueryable`1"/></param>
            <param name="searchText">搜索字符串，<seealso cref="M:System.String.IsNullOrWhiteSpace(System.String)"/>不执行，否则执行</param>
            <param name="predicate">筛选表达式</param>
            <returns>
            <paramref name="searchText"/>为true,返回新的<seealso cref="T:System.Collections.Generic.IEnumerator`1"/>
            否则返回<paramref name="queryable"/>
            </returns>
        </member>
        <member name="M:Yunzhi.Database.Extensions.Paging``1(System.Collections.Generic.IEnumerable{``0},Yunzhi.Database.Paged)">
            <summary>
            为<paramref name="collection"/>枚举集合分页
            </summary>
            <typeparam name="T">枚举集合条目类型</typeparam>
            <param name="collection">要分页的集合</param>
            <param name="page">分页设定及结果</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Database.IDbAccessAdapter">
            <summary>
            针对某一关系数据库产品的访问适配器
            </summary>
        </member>
        <member name="P:Yunzhi.Database.IDbAccessAdapter.Connection">
            <summary>
            获取或者设置当前数据库连接
            </summary>
        </member>
        <member name="P:Yunzhi.Database.IDbAccessAdapter.IsTransaction">
            <summary>
            获取当前是否指示要求接下来语句以事务形式提交
            </summary>
            <remarks>为true表示已经提示要求执行事务，但是未执行Commit()或者Rollback()</remarks>
        </member>
        <member name="P:Yunzhi.Database.IDbAccessAdapter.Syntax">
            <summary>
            获取或设置抽象Sql语法解析器
            </summary>
        </member>
        <member name="M:Yunzhi.Database.IDbAccessAdapter.Open">
            <summary>
            打开当前数据库连接
            </summary>
        </member>
        <member name="M:Yunzhi.Database.IDbAccessAdapter.Close">
            <summary>
            关闭当前数据库连接
            </summary>
        </member>
        <member name="M:Yunzhi.Database.IDbAccessAdapter.RunSqlCommand(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行Sql语句，但不返回值
            </summary>
            <param name="sqlCommand">要执行的Sql语句</param>
            <param name="parameters">Sql语所需的参数</param>
        </member>
        <member name="M:Yunzhi.Database.IDbAccessAdapter.RunSqlCommand(Yunzhi.Database.SqlStatement.Sql,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行Sql语句，但不返回值
            </summary>
            <param name="sqlStatement">要执行的抽象Sql语句</param>
            <param name="parameters">Sql语所需的参数</param>
        </member>
        <member name="M:Yunzhi.Database.IDbAccessAdapter.Select(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter},Yunzhi.Database.Paged)">
            <summary>
            执行SELECT语句并且返回查询结果
            </summary>
            <param name="sqlCommand">要执行的SELECT语句</param>
            <param name="parameters">SELECT语句所需要的参数</param>
            <param name="paged">分页设置和结果</param>
            <returns>查询的结果</returns>
        </member>
        <member name="M:Yunzhi.Database.IDbAccessAdapter.Select(Yunzhi.Database.SqlStatement.SelectStatement,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter},Yunzhi.Database.Paged)">
            <summary>
            执行SELECT语句并且返回查询结果
            </summary>
            <param name="sqlStatement">要执行的SELECT语句</param>
            <param name="parameters">SELECT语句所需要的参数</param>
            <param name="paged">分页设置和结果</param>
            <returns>查询的结果</returns>
        </member>
        <member name="M:Yunzhi.Database.IDbAccessAdapter.ExecProcedure(System.String,System.Data.SqlDbType,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行SQL语句，并返回执行返回值
            </summary>
            <param name="procedure">存储过程名称</param>
            <param name="dbType">返回值数据类型</param>
            <param name="parameters">存储过程参数</param>
            <returns>存储过程返回值（非输入参数)</returns>
        </member>
        <member name="M:Yunzhi.Database.IDbAccessAdapter.ExecProcedureToDs(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行SQL语句，并返回一个<seealso cref="T:System.Data.DataSet"/>
            </summary>
            <param name="procedure">存储过程名称</param>
            <param name="parameters">存储过程参数</param>
            <returns>返回填充好的DataSet</returns>
        </member>
        <member name="M:Yunzhi.Database.IDbAccessAdapter.BeginTransaction(System.Nullable{System.Data.IsolationLevel})">
            <summary>
            指示从现在开始本实例提交的所有Sql以事务形式执行，直到执行Commit或者Rollback方法
            </summary>
            <param name="level">指示事务的ISO锁定级别，不指定以库默认</param>
        </member>
        <member name="M:Yunzhi.Database.IDbAccessAdapter.Commit">
            <summary>
            提交当前执行的事务
            </summary>
        </member>
        <member name="M:Yunzhi.Database.IDbAccessAdapter.Rollback">
            <summary>
            回滚当前提交的事务
            </summary>
        </member>
        <member name="T:Yunzhi.Database.ISyntax">
            <summary>
            针对不同关系数据库产品语法解析器
            </summary>
        </member>
        <member name="P:Yunzhi.Database.ISyntax.Product">
            <summary>
            解析器的数据库产品
            </summary>
        </member>
        <member name="M:Yunzhi.Database.ISyntax.Resolve(Yunzhi.Database.SqlStatement.Sql)">
            <summary>
            将指定的抽象Sql语句解析成相关产品的Sql语句文本
            </summary>
            <param name="sql">要解析的抽象Sql语句</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="T:Yunzhi.Database.MsSqlServerDbAccessAdapter">
            <summary>
            Microsoft SQL Server数据访问适配器
            </summary>
        </member>
        <member name="P:Yunzhi.Database.MsSqlServerDbAccessAdapter.Connection">
            <summary>
            获取或设置当前数据库连接
            </summary>
        </member>
        <member name="P:Yunzhi.Database.MsSqlServerDbAccessAdapter.IsTransaction">
            <summary>
            获取当前是否指示要求接下来语句以事务形式提交
            </summary>
            <remarks>为true表示已经提示要求执行事务，但是未执行Commit()或者Rollback()</remarks>
        </member>
        <member name="P:Yunzhi.Database.MsSqlServerDbAccessAdapter.Syntax">
            <summary>
            获取或设置抽象Sql语法解析器
            </summary>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerDbAccessAdapter.#ctor">
            <summary>
            创建默认数据库访问适配器实例
            </summary>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerDbAccessAdapter.#ctor(System.String)">
            <summary>
            以指定的连接字符串创建访问适配器实例
            </summary>
            <param name="connectionString">连接字符串名(以{abc}的形式传入)，或者Sql的一个连接字符串</param>
            <remarks>如果以{abc}形式传入将去读取配器文件中的字符器</remarks>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerDbAccessAdapter.RunSqlCommand(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行Sql语句，但不返回值
            </summary>
            <param name="sqlCommand">要执行的Sql语句</param>
            <param name="parameters">Sql语所需的参数</param>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerDbAccessAdapter.Select(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter},Yunzhi.Database.Paged)">
            <summary>
            执行SELECT语句并且返回查询结果
            </summary>
            <param name="sqlCommand">要执行的SELECT语句</param>
            <param name="parameters">SELECT语句所需要的参数</param>
            <param name="paged">分页设置和结果</param>
            <returns>查询的结果</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerDbAccessAdapter.ExecProcedure(System.String,System.Data.SqlDbType,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行SQL语句，并返回执行返回值
            </summary>
            <param name="procedure">存储过程名称</param>
            <param name="dbType">返回值数据类型</param>
            <param name="parameters">存储过程参数</param>
            <returns>存储过程返回值（非输入参数)</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerDbAccessAdapter.ExecProcedureToDs(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行SQL语句，并返回一个<seealso cref="T:System.Data.DataSet"/>
            </summary>
            <param name="procedure">存储过程名称</param>
            <param name="parameters">存储过程参数</param>
            <returns>返回填充好的DataSet</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerDbAccessAdapter.BeginTransaction(System.Nullable{System.Data.IsolationLevel})">
            <summary>
            指示从现在开始本实例提交的所有Sql以事务形式执行，直到执行Commit或者Rollback方法
            </summary>
            <param name="level">指示事务的ISO锁定级别，不指定以库默认</param>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerDbAccessAdapter.Commit">
            <summary>
            提交当前执行的事务
            </summary>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerDbAccessAdapter.Rollback">
            <summary>
            回滚当前提交的事务
            </summary>
        </member>
        <member name="T:Yunzhi.Database.MsSqlServerSyntax">
            <summary>
            微软SQL Server语法解析器
            </summary>
        </member>
        <member name="P:Yunzhi.Database.MsSqlServerSyntax.Product">
            <summary>
            获取当前解析器所支持的数据库产品
            </summary>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveValue(System.Object)">
            <summary>
            将字段值格式化成相应的文本格式
            </summary>
            <param name="value">要格式的值</param>
            <returns>格式化后的文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveColumn(Yunzhi.Database.SqlStatement.DbColumn)">
            <summary>
            将表字段转换成供SELECT语句查询的字段形式
            </summary>
            <param name="dbColumn">要解析的字段</param>
            <returns>解析后的字符串</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveFunction(Yunzhi.Database.SqlStatement.DbFunction)">
            <summary>
            将函数调用转换成SQL文本形式
            </summary>
            <param name="function"></param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveSet(Yunzhi.Database.SqlStatement.DbColumn)">
            <summary>
            将数据字段解析成UPDATE语句设置字段
            </summary>
            <param name="dbColumn">要解析的字段</param>
            <returns>解析后的Sql文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveDbObject(Yunzhi.Database.SqlStatement.DbObject)">
            <summary>
            解析数据库对象成SQL文本
            </summary>
            <param name="dbobj">要解析的数据库对象</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveCondition(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            解析SQL条件表达式链
            </summary>
            <param name="root">要解析的SQL表达式链头表达式</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveGroupBy(Yunzhi.Database.SqlStatement.GroupByCondition)">
            <summary>
            解析SQL分组表达式
            </summary>
            <param name="groupby">分组表达式</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveOrderBy(System.Collections.Generic.IEnumerable{Yunzhi.Database.SqlStatement.OrderByCondition})">
            <summary>
            解析SQL条件表达式
            </summary>
            <param name="orderbys">要解析的排序表达式集</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveSelect(Yunzhi.Database.SqlStatement.SelectStatement)">
            <summary>
            解析抽象SELECT语句成SQL文本
            </summary>
            <param name="statement">要解析的SELECT抽象语句</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveInsert(Yunzhi.Database.SqlStatement.InsertStatement)">
            <summary>
            解析抽象INSERT语句成SQL文本
            </summary>
            <param name="statement">要解析的INSERT语句</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveUpdate(Yunzhi.Database.SqlStatement.UpdateStatement)">
            <summary>
            解析抽象UPDATE语句成SQL文本
            </summary>
            <param name="statement">要解析的UPDATE语句</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.resolveDelete(Yunzhi.Database.SqlStatement.DeleteStatement)">
            <summary>
            解析抽象DELETE语句成SQL文本
            </summary>
            <param name="statement">要解析的DELETE语句</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.Resolve(Yunzhi.Database.SqlStatement.Sql)">
            <summary>
            将指定的抽象Sql语句解析成SQL Server的Sql语句文本
            </summary>
            <param name="sql">要解析的抽象Sql语句</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.Resolve(Yunzhi.Database.SqlStatement.DbObject)">
            <summary>
            将指定数据库对象抽象语句解析成Sql语句文本
            </summary>
            <param name="dbObject">要解析数据对象表达式</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.Resolve(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            将指定条件表达式抽象语句解析成Sql语句文本
            </summary>
            <param name="condition">要解析的条件表达式</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MsSqlServerSyntax.Resolve(System.Collections.Generic.IEnumerable{Yunzhi.Database.SqlStatement.OrderByCondition})">
            <summary>
            将指定排序表达式抽象语句解析成Sql语句文本
            </summary>
            <param name="orderBy">要解析的排序表达式</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="T:Yunzhi.Database.MySqlDbAccessAdapter">
            <summary>
            MySql数据访问适配器
            </summary>
        </member>
        <member name="P:Yunzhi.Database.MySqlDbAccessAdapter.Connection">
            <summary>
            获取或设置当前数据库连接
            </summary>
        </member>
        <member name="P:Yunzhi.Database.MySqlDbAccessAdapter.IsTransaction">
            <summary>
            获取当前是否指示要求接下来语句以事务形式提交
            </summary>
            <remarks>为true表示已经提示要求执行事务，但是未执行Commit()或者Rollback()</remarks>
        </member>
        <member name="P:Yunzhi.Database.MySqlDbAccessAdapter.Syntax">
            <summary>
            获取或设置抽象Sql语法解析器
            </summary>
        </member>
        <member name="M:Yunzhi.Database.MySqlDbAccessAdapter.#ctor">
            <summary>
            创建默认数据库访问适配器实例
            </summary>
        </member>
        <member name="M:Yunzhi.Database.MySqlDbAccessAdapter.#ctor(System.String)">
            <summary>
            以指定的连接字符串创建访问适配器实例
            </summary>
            <param name="connectionString">连接字符串名(以{abc}的形式传入)，或者Sql的一个连接字符串</param>
            <remarks>如果以{abc}形式传入将去读取配器文件中的字符器</remarks>
        </member>
        <member name="M:Yunzhi.Database.MySqlDbAccessAdapter.RunSqlCommand(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行Sql语句，但不返回值
            </summary>
            <param name="sqlCommand">要执行的Sql语句</param>
            <param name="parameters">Sql语所需的参数</param>
        </member>
        <member name="M:Yunzhi.Database.MySqlDbAccessAdapter.Select(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter},Yunzhi.Database.Paged)">
            <summary>
            执行SELECT语句并且返回查询结果
            </summary>
            <param name="sqlCommand">要执行的SELECT语句</param>
            <param name="parameters">SELECT语句所需要的参数</param>
            <param name="paged">分页设置和结果</param>
            <returns>查询的结果</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlDbAccessAdapter.ExecProcedure(System.String,System.Data.SqlDbType,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行SQL语句，并返回执行返回值
            </summary>
            <param name="procedure">存储过程名称</param>
            <param name="dbType">返回值数据类型</param>
            <param name="parameters">存储过程参数</param>
            <returns>存储过程返回值（非输入参数)</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlDbAccessAdapter.ExecProcedureToDs(System.String,System.Collections.Generic.IEnumerable{System.Data.Common.DbParameter})">
            <summary>
            执行SQL语句，并返回一个<seealso cref="T:System.Data.DataSet"/>
            </summary>
            <param name="procedure">存储过程名称</param>
            <param name="parameters">存储过程参数</param>
            <returns>返回填充好的DataSet</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlDbAccessAdapter.BeginTransaction(System.Nullable{System.Data.IsolationLevel})">
            <summary>
            指示从现在开始本实例提交的所有Sql以事务形式执行，直到执行Commit或者Rollback方法
            </summary>
            <param name="level">指示事务的ISO锁定级别，不指定以库默认</param>
        </member>
        <member name="M:Yunzhi.Database.MySqlDbAccessAdapter.Commit">
            <summary>
            提交当前执行的事务
            </summary>
        </member>
        <member name="M:Yunzhi.Database.MySqlDbAccessAdapter.Rollback">
            <summary>
            回滚当前提交的事务
            </summary>
        </member>
        <member name="T:Yunzhi.Database.MySqlSyntax">
            <summary>
            Orace Mysql语法解析器
            </summary>
        </member>
        <member name="P:Yunzhi.Database.MySqlSyntax.Product">
            <summary>
            获取当前解析器所支持的数据库产品
            </summary>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveValue(System.Object)">
            <summary>
            将字段值格式化成相应的文本格式
            </summary>
            <param name="value">要格式的值</param>
            <returns>格式化后的文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveColumn(Yunzhi.Database.SqlStatement.DbColumn)">
            <summary>
            将表字段转换成供SELECT语句查询的字段形式
            </summary>
            <param name="dbColumn">要解析的字段</param>
            <returns>解析后的字符串</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveFunction(Yunzhi.Database.SqlStatement.DbFunction)">
            <summary>
            将函数调用转换成SQL文本形式
            </summary>
            <param name="function"></param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveSet(Yunzhi.Database.SqlStatement.DbColumn)">
            <summary>
            将数据字段解析成UPDATE语句设置字段
            </summary>
            <param name="dbColumn">要解析的字段</param>
            <returns>解析后的Sql文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveDbObject(Yunzhi.Database.SqlStatement.DbObject)">
            <summary>
            解析数据库对象成SQL文本
            </summary>
            <param name="dbobj">要解析的数据库对象</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveCondition(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            解析SQL条件表达式链
            </summary>
            <param name="root">要解析的SQL表达式链头表达式</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveGroupBy(Yunzhi.Database.SqlStatement.GroupByCondition)">
            <summary>
            解析SQL分组表达式
            </summary>
            <param name="groupby">分组表达式</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveOrderBy(System.Collections.Generic.IEnumerable{Yunzhi.Database.SqlStatement.OrderByCondition})">
            <summary>
            解析SQL条件表达式
            </summary>
            <param name="orderbys">要解析的排序表达式集</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveSelect(Yunzhi.Database.SqlStatement.SelectStatement)">
            <summary>
            解析抽象SELECT语句成SQL文本
            </summary>
            <param name="statement">要解析的SELECT抽象语句</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveInsert(Yunzhi.Database.SqlStatement.InsertStatement)">
            <summary>
            解析抽象INSERT语句成SQL文本
            </summary>
            <param name="statement">要解析的INSERT语句</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveUpdate(Yunzhi.Database.SqlStatement.UpdateStatement)">
            <summary>
            解析抽象UPDATE语句成SQL文本
            </summary>
            <param name="statement">要解析的UPDATE语句</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.resolveDelete(Yunzhi.Database.SqlStatement.DeleteStatement)">
            <summary>
            解析抽象DELETE语句成SQL文本
            </summary>
            <param name="statement">要解析的DELETE语句</param>
            <returns>SQL文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.Resolve(Yunzhi.Database.SqlStatement.Sql)">
            <summary>
            将指定的抽象Sql语句解析成SQL Server的Sql语句文本
            </summary>
            <param name="sql">要解析的抽象Sql语句</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.Resolve(Yunzhi.Database.SqlStatement.DbObject)">
            <summary>
            将指定数据库对象抽象语句解析成Sql语句文本
            </summary>
            <param name="dbObject">要解析数据对象表达式</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.Resolve(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            将指定条件表达式抽象语句解析成Sql语句文本
            </summary>
            <param name="condition">要解析的条件表达式</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="M:Yunzhi.Database.MySqlSyntax.Resolve(System.Collections.Generic.IEnumerable{Yunzhi.Database.SqlStatement.OrderByCondition})">
            <summary>
            将指定排序表达式抽象语句解析成Sql语句文本
            </summary>
            <param name="orderBy">要解析的排序表达式</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="T:Yunzhi.Database.Paged">
            <summary>
            数据查询分页设置和结果
            </summary>
        </member>
        <member name="P:Yunzhi.Database.Paged.PageIndex">
            <summary>
            获取或设置当前页码
            </summary>
        </member>
        <member name="P:Yunzhi.Database.Paged.PageSize">
            <summary>
            获取或设置页大小
            </summary>
        </member>
        <member name="P:Yunzhi.Database.Paged.RowCount">
            <summary>
            获取或设置记录总数
            </summary>
        </member>
        <member name="P:Yunzhi.Database.Paged.IsLazy">
            <summary>
            获取或设置是否为懒分页模式
            即：不返回<see cref="P:Yunzhi.Database.Paged.RowCount"/>和<see cref="P:Yunzhi.Database.Paged.PageCount"/>，直接到加载完成为止
            </summary>
        </member>
        <member name="P:Yunzhi.Database.Paged.Start">
            <summary>
            起始序号
            </summary>
        </member>
        <member name="P:Yunzhi.Database.Paged.End">
            <summary>
            获取截止序号
            </summary>
        </member>
        <member name="P:Yunzhi.Database.Paged.PageCount">
            <summary>
            获取总页数
            </summary>
        </member>
        <member name="M:Yunzhi.Database.Paged.#ctor(System.Int32,System.Int32,System.Int32)">
            <summary>
            创建分页实例
            </summary>
            <param name="index">当前页</param>
            <param name="size">分页大小</param>
            <param name="rowCount">记录总数</param>
        </member>
        <member name="M:Yunzhi.Database.Paged.#ctor(System.Int32,System.Int32,System.Boolean)">
            <summary>
            创建分页实例
            </summary>
            <param name="index">当前页</param>
            <param name="size">分页大小</param>
            <param name="isLazy">是否分懒分页式</param>
        </member>
        <member name="T:Yunzhi.Database.SqlProduct">
            <summary>
            各种关系数据库种类
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlProduct.MsSqlServer">
            <summary>
            Microsoft SQL Server
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlProduct.Oracle">
            <summary>
            Oracle
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlProduct.MySql">
            <summary>
            Oracle旗下的MySql
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlProduct.Sqlite">
            <summary>
            单文件数据库Sqlite
            </summary>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.DbColumn">
            <summary>
            表示一个表字段
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbColumn.Name">
            <summary>
            获取或设置字段名称
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbColumn.Aliases">
            <summary>
            获取或设置字段别名
            </summary>
            <remarks>在SELECT时生效，如： Id AS ClassIds</remarks>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbColumn.DbType">
            <summary>
            获取或设置字段数据类型
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbColumn.ObjectName">
            <summary>
            获取或设置字段来源数据库对象
            </summary>
            <remarks>比如表、视图名称</remarks>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbColumn.Value">
            <summary>
            获取或设置当前字段的值
            </summary>
            <remarks>SELECT时可以忽略此值</remarks>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbColumn.Resolve">
            <summary>
            获取或者设置值解析器
            </summary>
            <remarks>供上层二维表数据转实体时使用</remarks>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbColumn.#ctor">
            <summary>
            以默认方式初始化字段
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbColumn.#ctor(System.String,System.String,System.Object,System.String)">
            <summary>
            以基本参数实例初始化字段
            </summary>
            <param name="name">字段名称</param>
            <param name="aliases">字段别名</param>
            <param name="value">字段值</param>
            <param name="objectName">字段所属对象名称</param>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbColumn.New(System.String,System.String,System.Object,System.String)">
            <summary>
            创建一个新的字段实例
            </summary>
            <param name="name">字段名称</param>
            <param name="aliases">字段别名</param>
            <param name="value">字段值</param>
            <param name="objectName">字段所属对象名称</param>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbColumn.All(System.String)">
            <summary>
            快递创建一个 * 号所有字段访问实列
            </summary>
            <param name="objectName">字段来源数据库对象</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbColumn.Constant(System.Object,System.String)">
            <summary>
            创建一个常量字段 如 'CN' as [abc] 、 50 AS [abc]
            </summary>
            <param name="value">常量值</param>
            <param name="aliases">别名</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.DbFunction">
            <summary>
            表示一个数据的函数调用
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbFunction.Name">
            <summary>
            获取或设置函数名称
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbFunction.Parameters">
            <summary>
            获取或设置函数调用参数，可以传入<seealso cref="T:Yunzhi.Database.SqlStatement.DbColumn"/>实例
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbFunction.#ctor(System.String,System.Collections.Generic.IEnumerable{System.Object})">
            <summary>
            实例化一个新的函数
            </summary>
            <param name="name">函数名称</param>
            <param name="pars">函数调用要传递的实参列表，可以传入<seealso cref="T:Yunzhi.Database.SqlStatement.DbColumn"/>实例</param>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbFunction.New(System.String,System.Object[])">
            <summary>
            创建一个新的函数调用字段
            </summary>
            <param name="name">函数名称</param>
            <param name="pars">函数调用实参列表，可以是常量</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbFunction.New(System.String,System.String,System.Object[])">
            <summary>
            创建一个新的函数调用字段
            </summary>
            <param name="name">函数名称</param>
            <param name="aliases">别名</param>
            <param name="pars">函数调用实参列表，可以是常量</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.DbObject">
            <summary>
            表示一个数据库对象，如果表、视图、存储过程...
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbObject.Schema">
             <summary>
            获取或设置数据库对象所属架构
             </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbObject.Name">
            <summary>
            获取或设置对象名称
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbObject.Aliases">
            <summary>
            获取或设置对象别名
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbObject.PrevJoiner">
            <summary>
            获取或设置左边数据库对象（表、视图）的连接器
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbObject.NextJoiner">
            <summary>
            获取或设置右边数据库对象（表、视图）的连接器
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObject.ToString">
            <summary>
            重写基类方法 
            </summary>
            <returns>重写为默认为MsSql语法</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObject.#ctor">
            <summary>
            初始一个新的数据库对象实例
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObject.#ctor(System.String,System.String,System.String)">
            <summary>
            初始化一个新的数据库对象实例
            </summary>
            <param name="name">名称</param>
            <param name="aliases">别名</param>
            <param name="schema">所属架构</param>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObject.First">
            <summary>
            返回数据对象链中的头对象
            </summary>
            <returns>头数据库对象</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObject.Last">
            <summary>
            返回数据对象链中的末尾对象
            </summary>
            <returns>头数据库对象</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObject.Join(Yunzhi.Database.SqlStatement.DbObjectJoinType,System.String,System.String,System.String)">
            <summary>
            以指定的方式在右边连接一个新的数据库对象
            </summary>
            <param name="joinType">连接类型</param>
            <param name="name">右对象名称</param>
            <param name="aliases">右对象别名</param>
            <param name="schema">右对象所属架构名称</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObject.Inner(System.String,System.String,System.String)">
            <summary>
            以INNER JOIN连接的方式连接一个右数据库对象
            </summary>
            <param name="name">右对象名称</param>
            <param name="aliases">右对象别名</param>
            <param name="schema">右对象所属架构名称</param>
            <returns>新创建的连接对象</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObject.Left(System.String,System.String,System.String)">
            <summary>
            以INNER JOIN连接的方式连接一个右数据库对象
            </summary>
            <param name="name">右对象名称</param>
            <param name="aliases">右对象别名</param>
            <param name="schema">右对象所属架构名称</param>
            <returns>新创建的连接对象</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObject.Right(System.String,System.String,System.String)">
            <summary>
            以RIGHT JOIN连接的方式连接一个右数据库对象
            </summary>
            <param name="name">右对象名称</param>
            <param name="aliases">右对象别名</param>
            <param name="schema">右对象所属架构名称</param>
            <returns>新创建的连接对象</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObject.New(System.String,System.String,System.String)">
            <summary>
            提供一个快捷的实例新数据库对象的方法
            </summary>
            <param name="name">对象名称</param>
            <param name="aliases">别名</param>
            <param name="schema">所属架构</param>
            <returns>新实例</returns>
            <remarks>与实例方法一致</remarks>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.DbObjectJoiner">
            <summary>
            数据库对象连接器
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbObjectJoiner.LeftObject">
            <summary>
            获取或设置连接左数据对象
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbObjectJoiner.JoinType">
            <summary>
            获取或设置连接类型
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbObjectJoiner.RightObject">
            <summary>
            获取或设置连接右数据对象
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DbObjectJoiner.OnCondition">
            <summary>
            获取或设置连接的关连条件
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObjectJoiner.#ctor">
            <summary>
            初始化一个新的数据库对象连接器实例
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObjectJoiner.#ctor(Yunzhi.Database.SqlStatement.DbObjectJoinType,Yunzhi.Database.SqlStatement.DbObject)">
            <summary>
            初始化一个新的数据库对象连接器实例
            </summary>
            <param name="joinType">连接类型</param>
            <param name="dbObject">右边的数据库对象</param>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DbObjectJoiner.On(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            JOIN语句的连接条件表达式配置
            </summary>
            <param name="condition">连接表达式</param>
            <returns>返回当前连接器的右数据库对象</returns>
            <remarks>提供此返回是为了配置更多的JOIN对象</remarks>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.DbObjectJoinType">
            <summary>
            数据库（表、视图）连接类型
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.DbObjectJoinType.Inner">
            <summary>
            内连接
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.DbObjectJoinType.Left">
            <summary>
            左连接
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.DbObjectJoinType.Right">
            <summary>
            右连接
            </summary>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.DeleteStatement">
            <summary>
            表示一个DELETE语句
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DeleteStatement.#ctor">
            <summary>
            初始一个DELETE语句实例
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DeleteStatement.From(System.String,System.String)">
            <summary>
            设定要删除的表，即FROM子句
            </summary>
            <param name="tableName">要删除表的名称</param>
            <param name="schema">表所属的架构</param>
            <returns>当前语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DeleteStatement.Where(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            选择操作要限定的条件
            </summary>
            <param name="condition">要附加的条件</param>
            <returns>当前语句实例</returns>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.DmlStatement">
            <summary>
            Sql数据操纵语句（DML）基类，SELECT UPDATE DELETE EXECUTE...
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DmlStatement.Columns">
            <summary>
            获取或者设置要操作的字段集
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.DmlStatement.Condition">
            <summary>
            获取或者设置Where条件
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DmlStatement.#ctor">
            <summary>
            初始化一个新的Dml语句
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DmlStatement.Column(Yunzhi.Database.SqlStatement.DbColumn)">
            <summary>
            向当前语句添加一个操作字段
            </summary>
            <param name="column">要操作的字段</param>
            <returns>返回当前语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DmlStatement.From(Yunzhi.Database.SqlStatement.DbObject)">
            <summary>
            选择要操作的数据库对象
            </summary>
            <param name="dbObject">要操作的数据库对象</param>
            <returns>返回当前语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.DmlStatement.Where(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            选择操作要限定的条件
            </summary>
            <param name="condition">要附加的条件</param>
            <returns>返回当前语句实例</returns>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.ExecProcedure">
            <summary>
            表一个存储过程执行语句
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.ExecProcedure.ProcedureName">
            <summary>
            获取或设置存储过程名称
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.ExecProcedure.Parameters">
            <summary>
            获取或设置存储过程执行所需的参数
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.ExecProcedure.#ctor(System.String,System.Data.Common.DbParameter[])">
            <summary>
            初始化一个存储过程执行语句实例
            </summary>
            <param name="name">存储过程名称</param>
            <param name="parames">存储过程所需参数</param>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.GroupByCondition">
            <summary>
            表示Sql语句中的GROUP BY表达式
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.GroupByCondition.Columns">
            <summary>
            获取或设置分组字段
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.GroupByCondition.Condition">
            <summary>
            获取或设置分组条件
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.GroupByCondition.#ctor">
            <summary>
            初始化分组实例
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.GroupByCondition.By(System.String,System.String)">
            <summary>
            设置排序字段
            </summary>
            <param name="columnName">分组字段名称</param>
            <param name="objectName">字段属性数据库对象</param>
            <returns>当前分组条件实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.GroupByCondition.Having(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            设置分组条件
            </summary>
            <param name="condition">分组Sql表达式</param>
            <returns>返回<paramref name="condition"/>实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.GroupByCondition.New">
            <summary>
            静态公共方法
            </summary>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.InsertStatement">
            <summary>
            表示一个INSERT语句
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.InsertStatement.ValuesSelect">
            <summary>
            获取或设置INSERT语句中SELECT语句
            </summary>
            <remarks>如果不设置此语句，将读取<seealso cref="T:Yunzhi.Database.SqlStatement.DbColumn"/>中的Value属性</remarks>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.InsertStatement.#ctor">
            <summary>
            初始化一个INSERT语句实例
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.InsertStatement.Column(System.String,System.Object)">
            <summary>
            选一个要查询的列
            </summary>
            <param name="name">要插入的字段</param>
            <param name="value">要插入的值</param>
            <returns>当前语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.InsertStatement.Into(System.String,System.String)">
            <summary>
            选择要插入数据的表
            </summary>
            <param name="tableName">表名称</param>
            <param name="schema">表所属架构</param>
            <returns>返回当前语句实例</returns>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.OrderByCondition">
            <summary>
            表示一个Sql语句的排序表达式
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.OrderByCondition.Column">
            <summary>
            获取或设置排序字段
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.OrderByCondition.SortType">
            <summary>
            获取或设置排序类型
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.OrderByCondition.New(System.String,Yunzhi.Database.SqlStatement.OrderBySort)">
            <summary>
            创建一个新的排序表达式
            </summary>
            <param name="columnName">接受排序字段名称</param>
            <param name="sortType">排序类型</param>
            <returns>新的排序表达式</returns>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.OrderBySort">
            <summary>
            表示Sql语句中的OrderBy排序类型
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.OrderBySort.Ascending">
            <summary>
            升序
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.OrderBySort.Descending">
            <summary>
            降序
            </summary>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.SelectDbObject">
            <summary>
            表示一个以SELECT语句临时组成的表
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SelectDbObject.Select">
            <summary>
            获取或设置当前临时语句表的查询语句
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectDbObject.#ctor">
            <summary>
            默认初始方法
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectDbObject.#ctor(Yunzhi.Database.SqlStatement.SelectStatement,System.String)">
            <summary>
            以指定的语句和名称初始表数据库对象实例
            </summary>
            <param name="select">select语句</param>
            <param name="name">表命名</param>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.SelectStatement">
            <summary>
            表示一个SELECT语句
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SelectStatement.IsDistinct">
            <summary>
            获取或设置开启DISTINCT关键字
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SelectStatement.TopLimit">
            <summary>
            获取或设置启用TOP或者LIMIT查询的条数
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SelectStatement.Offset">
            <summary>
            获取或设置启用OFFSET偏移条数
            </summary>
            <remarks>Microsoft系数据库产品不支持此关键字</remarks>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SelectStatement.GroupBys">
            <summary>
            获取或设置分组表达式
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SelectStatement.OrderBys">
            <summary>
            获取或设置排序表达式
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.#ctor">
            <summary>
            初始化SELECT语句实例
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.Column(Yunzhi.Database.SqlStatement.DbColumn)">
            <summary>
            向当前语句添加一个操作字段
            </summary>
            <param name="column">要操作的字段</param>
            <returns>返回当前语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.Column(System.String,System.String,System.String)">
            <summary>
            选一个要查询的列
            </summary>
            <param name="name">字段名称</param>
            <param name="aliases">字段别名</param>
            <param name="objectName">数据库对象名称</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.Column(System.Object,System.String)">
            <summary>
            查询中指定一个常量值
            </summary>
            <param name="value">查询中指定的常量值</param>
            <param name="name">定义字段别名</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.From(Yunzhi.Database.SqlStatement.DbObject)">
            <summary>
            设定操作的数据库对象，即FROM子句
            </summary>
            <param name="dbObject">要操作的数据库对象</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.From(System.String,System.String,System.String)">
            <summary>
            选择要操作的数据库对象
            </summary>
            <param name="name">对象名称</param>
            <param name="aliases">别名</param>
            <param name="schema">所属架构</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.From(Yunzhi.Database.SqlStatement.SelectStatement,System.String)">
            <summary>
            选择要操作的数据库对象
            </summary>
            <param name="select"></param>
            <param name="aliases"></param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.InnerJoin(System.String,System.String,System.String)">
            <summary>
            向当前的操作员表增中一个INNER表关联
            </summary>
            <param name="name">要关联的表名称</param>
            <param name="aliases">要关联的表别名</param>
            <param name="schema">要关联的表所属架构</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.LeftJoin(System.String,System.String,System.String)">
            <summary>
            向当前的操作员表增中一个LEFT表关联
            </summary>
            <param name="name">要关联的表名称</param>
            <param name="aliases">要关联的表别名</param>
            <param name="schema">要关联的表所属架构</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.RightJoin(System.String,System.String,System.String)">
            <summary>
            向当前的操作员表增中一个LEFT表关联
            </summary>
            <param name="name">要关联的表名称</param>
            <param name="aliases">要关联的表别名</param>
            <param name="schema">要关联的表所属架构</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.On(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            为最后一个JOIN语句增加入ON条件
            </summary>
            <param name="condition">要在ON语句后面接的条件</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.On(System.String,System.String,System.String,System.String)">
            <summary>
            为最后一个JOIN语句增加入ON条件
            </summary>
            <param name="leftColumn">左表关联字段</param>
            <param name="leftTable">左表名称</param>
            <param name="rightColumn">右表关联字段</param>
            <param name="rightTable">右表名称</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.Where(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            增加WHERE语句
            </summary>
            <param name="condition">WHERE语句后面的条件</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.WhereAnd(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            在当前条件表达式<see cref="P:Yunzhi.Database.SqlStatement.DmlStatement.Condition"/>后面用AND运算符连接指定的表达式
            </summary>
            <param name="condition">要连接的表达式</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.WhereAnd(System.String,System.String,Yunzhi.Database.SqlStatement.SqlOperators,System.Object)">
            <summary>
            在当前条件表达式<seealso cref="P:Yunzhi.Database.SqlStatement.DmlStatement.Condition"/>后面用AND运算符连接一个新的表达式
            </summary>
            <param name="name">字段名称</param>
            <param name="objectName">字段所属对象名称（表、视图等）</param>
            <param name="operators">SQL运算符</param>
            <param name="value">表达式右侧值</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.WhereAnd(System.String,System.Object)">
            <summary>
            在当前条件表达式<seealso cref="P:Yunzhi.Database.SqlStatement.DmlStatement.Condition" />后面用AND运算符连接一个新的表达式（运算符为=）
            </summary>
            <param name="name">字段名称</param>
            <param name="value">表达式右侧值</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.WhereAnd(System.String,Yunzhi.Database.SqlStatement.SqlOperators,System.Object)">
            <summary>
            在当前条件表达式<seealso cref="P:Yunzhi.Database.SqlStatement.DmlStatement.Condition"/>后面用AND运算符连接一个新的表达式
            </summary>
            <param name="name">字段名称</param>
            <param name="operators">SQL运算符</param>
            <param name="value">表达式右侧值</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.WhereOr(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            在当前条件表达式<seealso cref="P:Yunzhi.Database.SqlStatement.DmlStatement.Condition"/>后面用OR运算符连接指定的表达式
            </summary>
            <param name="condition">要连接的表达式</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.WhereOr(System.String,System.String,Yunzhi.Database.SqlStatement.SqlOperators,System.Object)">
            <summary>
            在当前条件表达式<seealso cref="P:Yunzhi.Database.SqlStatement.DmlStatement.Condition"/>后面用Or运算符连接一个新的表达式
            </summary>
            <param name="name">字段名称</param>
            <param name="objectName">字段所属对象名称（表、视图等）</param>
            <param name="operators">SQL运算符</param>
            <param name="value">表达式右侧值</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.WhereOr(System.String,System.Object)">
            <summary>
            在当前条件表达式<seealso cref="P:Yunzhi.Database.SqlStatement.DmlStatement.Condition"/>后面用OR运算符连接一个新的表达式（运算符为=）
            </summary>
            <param name="name">字段名称</param>
            <param name="value">表达式右侧值</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.WhereOr(System.String,Yunzhi.Database.SqlStatement.SqlOperators,System.Object)">
            <summary>
            在当前条件表达式<seealso cref="P:Yunzhi.Database.SqlStatement.DmlStatement.Condition"/>后面用OR运算符连接一个新的表达式
            </summary>
            <param name="name">字段名称</param>
            <param name="operators">SQL运算符</param>
            <param name="value">表达式右侧值</param>
            <returns>当前SELECT语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.Top(System.Int32)">
            <summary>
            插入TOP关键字
            </summary>
            <param name="rowsNum">要返回前多少条记录</param>
            <returns>当前语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.Limit(System.Int32,System.Int32)">
            <summary>
            插入LIMIT...OFFSET...参数
            </summary>
            <param name="rowsNum">要返回的记录条数</param>
            <param name="offset">设定的偏移条数</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.Distinct">
            <summary>
            插入DISTINCT关键字
            </summary>
            <returns>当前语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.OrderBy(Yunzhi.Database.SqlStatement.DbColumn,Yunzhi.Database.SqlStatement.OrderBySort)">
            <summary>
            向当前SELECT语句增加一个排序表达式
            </summary>
            <param name="column">要排序的字段</param>
            <param name="sort">排序方式</param>
            <returns>当前语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.OrderByDescending(System.String,System.String)">
            <summary>
            增加一个降序表达式化
            </summary>
            <param name="columnName">排序字段名称</param>
            <param name="dbObject">字段所属数据库对象名称</param>
            <returns>当前语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.OrderByAscending(System.String,System.String)">
            <summary>
            增加一个升序表达式化
            </summary>
            <param name="columnName">排序字段名称</param>
            <param name="dbObject">字段所属数据库对象名称</param>
            <returns>当前语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SelectStatement.GroupBy(Yunzhi.Database.SqlStatement.GroupByCondition)">
            <summary>
            设定分组语句
            </summary>
            <returns>当前语句实例</returns>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.Sql">
            <summary>
            Sql语句抽象基类
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.Sql.Verb">
            <summary>
            获取或设置Sql语句执行动词
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.Sql.Object">
            <summary>
            获取或者设置语句要操作数据库对象
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.Sql.Select">
            <summary>
            创建一个新的SELECT抽象语句
            </summary>
            <returns>SELECT抽象语句</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.Sql.Insert">
            <summary>
            创建一个新的INSERT抽象语句
            </summary>
            <returns>INSERT抽象语句</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.Sql.Update">
            <summary>
            创建一个新的UPDATE抽象语句
            </summary>
            <returns>UPDATE抽象语句</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.Sql.Delete">
            <summary>
            创建一个新的DELETE抽象语句
            </summary>
            <returns>DELETE抽象语句</returns>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.SqlCondition">
            <summary>
            Sql语句条件表达式
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SqlCondition.Before">
            <summary>
            获取或设置前一个条件
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SqlCondition.Column">
            <summary>
            获取或设置条件字段
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SqlCondition.Operator">
            <summary>
            获取或设置条件逻辑运算符
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SqlCondition.Link">
            <summary>
            获取或设置与<see cref="P:Yunzhi.Database.SqlStatement.SqlCondition.After"/>链接的逻辑运算符
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SqlCondition.After">
            <summary>
            获取或设置后一个条件
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.#ctor">
            <summary>
            初始化一个空的条件表达式
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.#ctor(System.String,Yunzhi.Database.SqlStatement.SqlOperators,Yunzhi.Database.SqlStatement.SqlDbInduceType,System.Object)">
            <summary>
            以字段参数实例化一个新的条件
            </summary>
            <param name="columnName">字段名称</param>
            <param name="operation">运算符</param>
            <param name="dbType">数据类型</param>
            <param name="value">条件值</param>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.Root">
            <summary>
            从当前表达式向上回朔寻找当前表达式树的根链最左侧表达式
            </summary>
            <returns>找到的根链的中最左侧表达式</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.First">
            <summary>
            从当前表达式向左回朔寻找到当前表达式链中最左侧的表达式
            </summary>
            <returns>找到的当前链最左侧表达式</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.Last">
            <summary>
            从当前表达式向右寻找到当前表达式链中最右侧的表达式
            </summary>
            <returns>找到的当前链最右侧表达式</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.Or(System.String,System.Object)">
            <summary>
            创建一个等于<seealso cref="T:Yunzhi.Database.SqlStatement.SqlCondition"/>实例，并以Or方式连接在当前表达式右侧
            </summary>
            <param name="columnName">字段名称</param>
            <param name="value">条件值</param>
            <returns>创建的新的表达式</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.Or(System.String,Yunzhi.Database.SqlStatement.SqlOperators,System.Object,Yunzhi.Database.SqlStatement.SqlDbInduceType)">
            <summary>
            以传入的参数实例一个新的<seealso cref="T:Yunzhi.Database.SqlStatement.SqlCondition"/>实例，并以Or方式连接在当前表达式右侧
            </summary>
            <param name="columnName">字段名称</param>
            <param name="operators">运算符</param>
            <param name="dbType">字段数据类型</param>
            <param name="value">条件值</param>
            <returns>创建的新的表达式</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.Or(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            以Or将指定的表达式链接在本表达式的右侧
            </summary>
            <param name="condition">要链接的表达式</param>
            <returns>返回<paramref name="condition"/>实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.And(System.String,System.Object)">
            <summary>
            创建一个等于<seealso cref="T:Yunzhi.Database.SqlStatement.SqlCondition"/>实例，并以And方式连接在当前表达式右侧
            </summary>
            <param name="columnName">字段名称</param>
            <param name="value">条件值</param>
            <returns>创建的新的表达式</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.And(System.String,Yunzhi.Database.SqlStatement.SqlOperators,System.Object,Yunzhi.Database.SqlStatement.SqlDbInduceType)">
            <summary>
            以传入的参数实例一个新的<seealso cref="T:Yunzhi.Database.SqlStatement.SqlCondition"/>实例，并以And方式链接在右侧
            </summary>
            <param name="columnName">字段名称</param>
            <param name="operators">运算符</param>
            <param name="dbType">字段数据类型</param>
            <param name="value">条件值</param>
            <returns>创建的新的表达式</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.And(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            以And将指定的表达式链接在本表达式的右侧
            </summary>
            <param name="condition">要链接的表达式</param>
            <returns>返回<paramref name="condition"/>实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.New(System.String,System.Object)">
            <summary>
            创建一个操作符为=的新表达式实例
            </summary>
            <param name="columnName">字段名称</param>
            <param name="value">值</param>
            <returns>新表达式实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlCondition.New(System.String,Yunzhi.Database.SqlStatement.SqlOperators,System.Object)">
            <summary>
            创建一个新的表达式实例
            </summary>
            <param name="columnName">字段名称</param>
            <param name="operation">运算符</param>
            <param name="value">值</param>
            <returns>新表达式实例</returns>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.SqlConditionLinks">
            <summary>
            Sql条件连接运算符
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlConditionLinks.And">
            <summary>
            AND连接
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlConditionLinks.Or">
            <summary>
            OR连接
            </summary>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.SqlConditionWrap">
            <summary>
            Sql条件表达式括在一起，即()子表达式
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SqlStatement.SqlConditionWrap.Wraps">
            <summary>
            获取或设置被包括的表达式
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlConditionWrap.New(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            创建一个新的括号（子）式实体
            </summary>
            <param name="condition">括号要包含的表达式，可以要括住的表达式链的任意节点的表达式，将搜索头表达式。</param>
            <returns>新的括号（子）表达式实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlConditionWrap.New(System.Collections.Generic.IEnumerable{Yunzhi.Database.SqlStatement.SqlCondition},Yunzhi.Database.SqlStatement.SqlConditionLinks)">
            <summary>
            创建一个新的括号（子）式实体，子表达式内以<paramref name="link"/>连接<paramref name="conditions"/>各表达式
            </summary>
            <param name="conditions">要连接的子表达式集</param>
            <param name="link">子表式连接符</param>
            <returns>新的括号（子）表达式实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlConditionWrap.NewOr(System.Collections.Generic.IEnumerable{Yunzhi.Database.SqlStatement.SqlCondition})">
            <summary>
            创建一个新的括号（子）式实体，子表达式内以Or连接<paramref name="conditions"/>各表达式
            </summary>
            <param name="conditions">要连接的子表达式集</param>
            <returns>新的括号（子）表达式实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlConditionWrap.NewOr(Yunzhi.Database.SqlStatement.SqlCondition[])">
            <summary>
            创建一个新的括号（子）式实体，子表达式内以Or连接<paramref name="conditions"/>各表达式
            </summary>
            <param name="conditions">要连接的子表达式集</param>
            <returns>新的括号（子）表达式实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlConditionWrap.NewAnd(System.Collections.Generic.IEnumerable{Yunzhi.Database.SqlStatement.SqlCondition})">
            <summary>
            创建一个新的括号（子）式实体，子表达式内以And连接<paramref name="conditions"/>各表达式
            </summary>
            <param name="conditions">要连接的子表达式集</param>
            <returns>新的括号（子）表达式实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.SqlConditionWrap.NewAnd(Yunzhi.Database.SqlStatement.SqlCondition[])">
            <summary>
            创建一个新的括号（子）式实体，子表达式内以And连接<paramref name="conditions"/>各表达式
            </summary>
            <param name="conditions">要连接的子表达式集</param>
            <returns>新的括号（子）表达式实例</returns>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.SqlDbInduceType">
            <summary>
            Sql归类归纳数据类型
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlDbInduceType.Var">
            <summary>
            推断类型
            </summary>
            <remarks>即在如INSERT,UPDATE,WHERE条件表达式等中，不明确指定数据类型，通过Value的CTS类型来推断具体的数据类型</remarks>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlDbInduceType.Numeric">
            <summary>
            数字
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlDbInduceType.String">
            <summary>
            字符串
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlDbInduceType.Datetime">
            <summary>
            日期时间
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlDbInduceType.Byte">
            <summary>
            字节
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlDbInduceType.Binary">
            <summary>
            二进制流
            </summary>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.SqlOperators">
            <summary>
            Sql条件条件逻辑运算符
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.Equal">
            <summary>
            等于
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.GreaterThan">
            <summary>
            大于
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.LessThan">
            <summary>
            小于
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.GreaterThanEqual">
            <summary>
            大于等于
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.LessThanEqual">
            <summary>
            小于等于
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.NotEqual">
            <summary>
            不等于
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.Like">
            <summary>
            LIKE
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.Bettwen">
            <summary>
            BETWEEN...AND...
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.Is">
            <summary>
            IS
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.IsNot">
            <summary>
            IS NOT
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.In">
            <summary>
            IN
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlOperators.NotIn">
            <summary>
            NOT IN
            </summary>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.SqlVerbs">
            <summary>
            Sql语句的各种动词
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlVerbs.Insert">
            <summary>
            INSERT插入操作
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlVerbs.Update">
            <summary>
            UPDATE更新操作
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlVerbs.Delete">
            <summary>
            DELETE删除操作
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlVerbs.Select">
            <summary>
            SELECT查询操作
            </summary>
        </member>
        <member name="F:Yunzhi.Database.SqlStatement.SqlVerbs.Procedure">
            <summary>
            EXEC PROCEDURE执行操作存储过程
            </summary>
        </member>
        <member name="T:Yunzhi.Database.SqlStatement.UpdateStatement">
            <summary>
            表示一个UPDATE语句
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.UpdateStatement.#ctor">
            <summary>
            初始化一个UPDATE语句
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.UpdateStatement.From(System.String,System.String)">
            <summary>
            选择要更新的表
            </summary>
            <param name="tableName">表名称</param>
            <param name="schema">表所属架构</param>
            <returns>返回当前语句实例</returns>
        </member>
        <member name="M:Yunzhi.Database.SqlStatement.UpdateStatement.Set(System.String,System.Object)">
            <summary>
            选一个要SET的列
            </summary>
            <param name="name">要更新的字段名称</param>
            <param name="value">字段要设定的值</param>
            <returns>当前语句实例</returns>
        </member>
        <member name="T:Yunzhi.Database.SyntaxBase">
            <summary>
            语法解析器基类
            </summary>
        </member>
        <member name="P:Yunzhi.Database.SyntaxBase.Product">
            <summary>
            解析器的数据库产品
            </summary>
        </member>
        <member name="M:Yunzhi.Database.SyntaxBase.Resolve(Yunzhi.Database.SqlStatement.Sql)">
            <summary>
            将指定的抽象Sql语句解析成相关产品的Sql语句文本
            </summary>
            <param name="sql">要解析的抽象Sql语句</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="M:Yunzhi.Database.SyntaxBase.Resolve(Yunzhi.Database.SqlStatement.DbObject)">
            <summary>
            将指定数据库对象抽象语句解析成Sql语句文本
            </summary>
            <param name="dbObject">要解析数据对象表达式</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="M:Yunzhi.Database.SyntaxBase.Resolve(Yunzhi.Database.SqlStatement.SqlCondition)">
            <summary>
            将指定条件表达式抽象语句解析成Sql语句文本
            </summary>
            <param name="condition">要解析的条件表达式</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="M:Yunzhi.Database.SyntaxBase.Resolve(System.Collections.Generic.IEnumerable{Yunzhi.Database.SqlStatement.OrderByCondition})">
            <summary>
            将指定排序表达式抽象语句解析成Sql语句文本
            </summary>
            <param name="orderBy">要解析的排序表达式</param>
            <returns>Sql语句文本</returns>
        </member>
        <member name="M:Yunzhi.Database.SyntaxBase.GetInduceType(System.Type)">
            <summary>
            根据CTS类型确认相应的归纳类型
            </summary>
            <param name="ctsType">接受判断的类型</param>
            <returns>返回相应的归纳类型</returns>
            <remarks>非值类型时，直接确认为String类型</remarks>
        </member>
        <member name="M:Yunzhi.Database.SyntaxBase.GetInduceType(System.Object)">
            <summary>
            根据值的类型确定相应的归纳类型
            </summary>
            <param name="value">值</param>
            <remarks>非值类型时，直接确认为String类型</remarks>
        </member>
        <member name="M:Yunzhi.Database.SyntaxBase.LikeChar(System.String)">
            <summary>
            为<paramref name="value"/>左右两侧增加一个LIKE通配符%
            </summary>
            <param name="value">要增加通配的值</param>
            <returns>如果<paramref name="value"/>为null则返回%；否则返回%value%</returns>
        </member>
        <member name="M:Yunzhi.Database.SyntaxBase.LikeCharLeft(System.String)">
            <summary>
            为<paramref name="value"/>左两侧增加一个LIKE通配符%
            </summary>
            <param name="value">要增加通配的值</param>
            <returns>如果<paramref name="value"/>为null则返回%；否则返回%value%</returns>
        </member>
        <member name="M:Yunzhi.Database.SyntaxBase.LikeCharRight(System.String)">
            <summary>
            为<paramref name="value"/>右两侧增加一个LIKE通配符%
            </summary>
            <param name="value">要增加通配的值</param>
            <returns>如果<paramref name="value"/>为null则返回%；否则返回%value%</returns>
        </member>
        <member name="T:Yunzhi.Implement.TriggerToken">
            <summary>
            一个通用的<seealso cref="T:Microsoft.Extensions.Primitives.IChangeToken"/>实现
            可以实现化订阅（取消订阅)、触发
            </summary>
            
        </member>
        <member name="M:Yunzhi.Implement.TriggerToken.#ctor">
            <summary>
            初始化领令牌
            </summary>
        </member>
        <member name="P:Yunzhi.Implement.TriggerToken.ActiveChangeCallbacks">
            <summary>
            获取是否自动通知变化，一直返回true
            </summary>
        </member>
        <member name="P:Yunzhi.Implement.TriggerToken.HasChanged">
            <inheritdoc />
        </member>
        <member name="M:Yunzhi.Implement.TriggerToken.RegisterChangeCallback(System.Action{System.Object},System.Object)">
            <inheritdoc />
        </member>
        <member name="M:Yunzhi.Implement.TriggerToken.Triggering">
            <summary>
            引发通知
            即将<see cref="P:Yunzhi.Implement.TriggerToken.HasChanged"/>设为true
            </summary>
        </member>
        <member name="T:Yunzhi.Implement.TriggerTokenSource">
            <summary>
            <seealso cref="P:Yunzhi.Implement.TriggerTokenSource.TriggerToken"/>源
            创建、操作<seealso cref="T:Yunzhi.Implement.TriggerTokenSource"/>实例
            </summary>
        </member>
        <member name="P:Yunzhi.Implement.TriggerTokenSource.TriggerToken">
            <summary>
            获取最后一次创建的<seealso cref="P:Yunzhi.Implement.TriggerTokenSource.TriggerToken"/>
            </summary>
        </member>
        <member name="M:Yunzhi.Implement.TriggerTokenSource.#ctor">
            <summary>
            初始化源
            </summary>
        </member>
        <member name="M:Yunzhi.Implement.TriggerTokenSource.New">
            <summary>
            创建一个新的<seealso cref="P:Yunzhi.Implement.TriggerTokenSource.TriggerToken"/>实例
            注意：如果当前<see cref="P:Yunzhi.Implement.TriggerTokenSource.TriggerToken"/>实例的<seealso cref="P:Yunzhi.Implement.TriggerToken.HasChanged"/>为false时
            不会创建新实例，直接返回<see cref="P:Yunzhi.Implement.TriggerTokenSource.TriggerToken"/>。
            </summary>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Implement.TriggerTokenSource.Triggering">
            <summary>
            引发通知，即触发<see cref="P:Yunzhi.Implement.TriggerToken.HasChanged"/>的
            </summary>
        </member>
        <member name="T:Yunzhi.Logging.Configuration.LoggerElement">
            <summary>
            表示一个日志写入配置元素
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.Configuration.LoggerElement.Name">
            <summary>
            获取或设置记录名称
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.Configuration.LoggerElement.Logger">
            <summary>
            获取或设置日志提供程序名称
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.Configuration.LoggerElement.Parameters">
            <summary>
            获取当前记录器下的配置参数集合
            </summary>
        </member>
        <member name="T:Yunzhi.Logging.Log">
            <summary>
            日志记录管理入口
            </summary>
        </member>
        <member name="M:Yunzhi.Logging.Log.#cctor">
            <summary>
            静态初始化。
            </summary>
        </member>
        <member name="M:Yunzhi.Logging.Log.GetInvokeStack">
            <summary>
            返回最后一级调用堆栈
            </summary>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Logging.Log.GetInvokeStacks">
            <summary>
            获取所有调用堆栈
            </summary>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Logging.Log.FormatException(System.Exception,System.Text.StringBuilder)">
            <summary>
            格式化异常输出
            </summary>
            <param name="exception">要输出的异常</param>
            <param name="build">循环输出的错误文本</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Logging.Log.GetConfiguration">
            <summary>
            获取当前日志配置
            </summary>
            <returns>日志配置节点实例</returns>
        </member>
        <member name="M:Yunzhi.Logging.Log.GetLogger(System.String)">
            <summary>
            获取指定名称的
            </summary>
            <param name="name">日志记录器配置节点名称</param>
            <returns>如果存在则返回实例，否则返回null。</returns>
        </member>
        <member name="M:Yunzhi.Logging.Log.Write(System.String,Yunzhi.Logging.LogLevel,System.String,System.String)">
            <summary>
            调用指定的日志记录器写入一条日志
            </summary>
            <param name="logName">日志记录器名称</param>
            <param name="level">日志级别</param>
            <param name="source">事件触发来源</param>
            <param name="descript">事件描述信息</param>
        </member>
        <member name="M:Yunzhi.Logging.Log.Info(System.String,System.String,System.String)">
            <summary>
            写入一条消息日志
            </summary>
            <param name="descript">要输出的日志说明</param>
            <param name="source">日志输入源</param>
            <param name="logName">日志记录器名称</param>
        </member>
        <member name="M:Yunzhi.Logging.Log.Debug(System.String,System.String,System.String)">
            <summary>
            写入一条调试提示日志。
            </summary>
            <param name="logName">日志记录器名称</param>
            <param name="descript">事件描述信息</param>
            <param name="source">事件触发来源</param>
            <remarks>调用日志如果指定的<paramref name="source"/>日志记录器不存在，则不输出</remarks>
        </member>
        <member name="M:Yunzhi.Logging.Log.Wraning(System.String,System.String,System.String)">
            <summary>
            写入一条警告日志。
            </summary>
            <param name="logName">日志记录器名称</param>
            <param name="descript">事件描述信息</param>
            <param name="source">事件触发来源</param>
        </member>
        <member name="M:Yunzhi.Logging.Log.Error(System.String,System.String,System.String)">
            <summary>
            写入一条错误日志。
            </summary>
            <param name="logName">日志记录器名称</param>
            <param name="descript">事件描述信息</param>
            <param name="source">事件触发来源</param>
        </member>
        <member name="M:Yunzhi.Logging.Log.Error(System.Exception,System.String,System.String)">
            <summary>
            写入一条异常信息错误日志
            </summary>
            <param name="logName">日志记录器名称</param>
            <param name="exception">事件描述信息</param>
            <param name="source">事件触发来源</param>
        </member>
        <member name="T:Yunzhi.Logging.LoggerBase">
            <summary>
            日志记录器基类
            </summary>
        </member>
        <member name="M:Yunzhi.Logging.LoggerBase.#ctor">
            <summary>
            以默认方式初始化一个实例
            </summary>
        </member>
        <member name="M:Yunzhi.Logging.LoggerBase.#ctor(Yunzhi.Logging.Configuration.LoggerElement)">
            <summary>
            用日志配置文件实始化一个实例
            </summary>
            <param name="config">日志记录器配置</param>
        </member>
        <member name="M:Yunzhi.Logging.LoggerBase.Write(Yunzhi.Logging.LogRecord)">
            <summary>
            写日志存储对象写入一条日志，继承类实现此方法
            </summary>
            <param name="log">待写入日志</param>
        </member>
        <member name="T:Yunzhi.Logging.LogLevel">
            <summary>
            日志级别
            </summary>
        </member>
        <member name="F:Yunzhi.Logging.LogLevel.None">
            <summary>
            
            </summary>
        </member>
        <member name="F:Yunzhi.Logging.LogLevel.Debug">
            <summary>
            用于调试信息
            </summary>
        </member>
        <member name="F:Yunzhi.Logging.LogLevel.Info">
            <summary>
            信息输出
            </summary>
        </member>
        <member name="F:Yunzhi.Logging.LogLevel.Wraning">
            <summary>
            警告
            </summary>
        </member>
        <member name="F:Yunzhi.Logging.LogLevel.Error">
            <summary>
            错误
            </summary>
        </member>
        <member name="T:Yunzhi.Logging.LogRecord">
            <summary>
            表示一条日志记录
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.LogRecord.Id">
            <summary>
            获取或设置事件标识
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.LogRecord.Logger">
            <summary>
            获取或设置定义Log记录器名称
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.LogRecord.Source">
            <summary>
            获取或设置事件触发的源
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.LogRecord.Datetime">
            <summary>
            获取或设置事件触发时间
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.LogRecord.Level">
            <summary>
            获取或设置日志级别
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.LogRecord.Descript">
            <summary>
            获取或设置事件描述
            </summary>
        </member>
        <member name="T:Yunzhi.Logging.MongoDbLogger">
            <summary>
            MongoDb集中存储日志
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.MongoDbLogger.ConnectionString">
            <summary>
            获取或设置MongoDB连接字符串
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.MongoDbLogger.CollectionName">
            <summary>
            获取或设置存储日志的集成名称
            </summary>
        </member>
        <member name="M:Yunzhi.Logging.MongoDbLogger.#cctor">
            <summary>
            全局初始化
            </summary>
        </member>
        <member name="M:Yunzhi.Logging.MongoDbLogger.#ctor(Yunzhi.Logging.Configuration.LoggerElement)">
            <summary>
            以配置记录器配置元素配置文件初始化实例
            </summary>
            <param name="config">配置元素</param>
        </member>
        <member name="M:Yunzhi.Logging.MongoDbLogger.CreateCollection">
            <summary>
            创建MongoDB访问集合
            </summary>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Logging.MongoDbLogger.EnsureIndexes">
            <summary>
            创建索引
            </summary>
        </member>
        <member name="M:Yunzhi.Logging.MongoDbLogger.Write(Yunzhi.Logging.LogRecord)">
            <inheritdoc />
        </member>
        <member name="T:Yunzhi.Logging.TextFileLogger">
            <summary>
            文本文件日志记录器
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.TextFileLogger.Path">
            <summary>
            获取或设置日志存储路径
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.TextFileLogger.FileStyle">
            <summary>
            获取或设置文件名风格
            </summary>
            <example><![CDATA[Debug-{0:yyyy-MM-dd}.log]]></example>
            <remarks>接受String.Format的格式字符串，第一参数为当前日期</remarks>
        </member>
        <member name="P:Yunzhi.Logging.TextFileLogger.MaxLength">
            <summary>
            获取或设置单个日志文件最大的允许容量，单位M
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.TextFileLogger.Head">
            <summary>
            获取或设置日志文件头文本
            </summary>
        </member>
        <member name="P:Yunzhi.Logging.TextFileLogger.LogStyle">
            <summary>
            获取或设置日志记录格式化字符串
            </summary>
            <remarks>接受String.Format的格式字符串，参数：Id、Datetime、Source、Level、Descript</remarks>
        </member>
        <member name="M:Yunzhi.Logging.TextFileLogger.#ctor">
            <summary>
            以默认方式初始化一个文本文件记录器实例
            </summary>
        </member>
        <member name="M:Yunzhi.Logging.TextFileLogger.#ctor(Yunzhi.Logging.Configuration.LoggerElement)">
            <summary>
            以配置记录器配置元素配置文件初始化实例
            </summary>
            <param name="config">配置元素</param>
        </member>
        <member name="M:Yunzhi.Logging.TextFileLogger.Write(Yunzhi.Logging.LogRecord)">
            <summary>
            写日志存储对象写入一条日志，继承类实现此方法
            </summary>
            <param name="log">待写入日志</param>
        </member>
        <member name="T:Yunzhi.Net.HttpAccessor">
            <summary>
            HTTP快捷访问助手（客户端）
            </summary>
            <remarks>
            提供Cookie缓存功能（仅实例周期，非持久化保存)
            建议改用<seealso cref="T:Yunzhi.Net.HttpWebAccessor"/>，基于HttpClient实现，具有更高的性能
            </remarks>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.CacheCookie(System.Net.HttpWebResponse)">
            <summary>
            缓存Cookie
            </summary>
            <param name="response">服务器响应的请求</param>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.InitRequest(System.Net.HttpWebRequest)">
            <summary>
            对HTTP请求作初始工作，主要初始请求头，附加cookie
            </summary>
            <param name="request">要初始的请求头</param>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.GetEncoding(System.Net.HttpWebResponse)">
            <summary>
            判定当前的响应的编码系统是存支持，否则返回默认编码
            </summary>
            <param name="response">当前响应</param>
            <returns></returns>
        </member>
        <member name="P:Yunzhi.Net.HttpAccessor.DefaultEncoding">
            <summary>
            获取或设置当HTTP响应未给出编码头时默认使用什么编码解码。
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpAccessor.DefaultUserAgent">
            <summary>
            获取或设置默认UserAgent
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpAccessor.Before">
            <summary>
            获取或设置默认的请求前处理行为
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpAccessor.Cookied">
            <summary>
            获取或设置是否要开启cookie缓存（解析）。
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpAccessor.Cookies">
            <summary>
            获取当前请求助手实例缓存的Cookie
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpAccessor.LastHttp">
            <summary>
            获取最后一次的HTTP请求过程
            </summary>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.#ctor">
            <summary>
            初始化HTTP请求助手
            </summary>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.Through(System.String,System.Boolean,System.Collections.Generic.Dictionary{System.String,System.String})">
            <summary>
            透明HTTP请求处理，以解决响应非标准RFC响应的BUG
            </summary>
            <param name="url">请求的URL</param>
            <param name="isPost">是否为POST否则GET</param>
            <param name="parames">请求参数</param>
            <returns></returns>
            <remarks>目前仅支持GET请求</remarks>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.ThroughToJson(System.String,System.Boolean,System.Collections.Generic.Dictionary{System.String,System.String})">
            <summary>
            向指定的URL发送GET请求，并返回解析后的JSON数据
            </summary>
            <param name="url">要请求的URL</param>
            <param name="isPost">是否为POST否则GET</param>
            <param name="parames">跟在后面的url参数，默认为空</param>
            <returns>标识响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.Get(System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Action{System.Net.HttpWebRequest})">
            <summary>
            向指定的URL发送GET请求，并返回标识响应
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">跟在后面的url参数，默认为空</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>标识响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.GetToPlain(System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Action{System.Net.HttpWebRequest})">
            <summary>
            向指定的URL发送GET请求，并返回解析后的纯文本
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">跟在后面的url参数，默认为空</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>标识响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.GetToJson(System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Action{System.Net.HttpWebRequest})">
            <summary>
            向指定的URL发送GET请求，并返回解析后的JSON数据
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">跟在后面的url参数，默认为空</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>标识响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.Post(System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Action{System.Net.HttpWebRequest})">
            <summary>
            向指定的URL发送POST请求，并返回解析后的标准响应
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">Body区域的表单键值对，默认为空</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>标识响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.PostToPlain(System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Action{System.Net.HttpWebRequest})">
            <summary>
            向指定的URL发送POST请求，并返回解析后的解析后的纯文本
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">Body区域的表单键值对，默认为空</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>响应的纯文本数据</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.PostToJson(System.String,System.Collections.Generic.Dictionary{System.String,System.String},System.Action{System.Net.HttpWebRequest})">
            <summary>
            向指定的URL发送POST请求，并返回解析后的JSON数据
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">Body区域的表单键值对，默认为空</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>响应的JSON数据</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.PostToJson(System.String,System.Object,System.Action{System.Net.HttpWebRequest})">
            <summary>
            向指定的URL发送POST请求，并返回解析后的JSON数据
            </summary>
            <param name="url">要请求的URL</param>
            <param name="jsonData">要POST提交的JSON形式数据的对象，不为null将自动JSON序列化</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>响应的JSON数据</returns>
            <remarks>content-type，将改为application/json</remarks>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.Upload(System.String,System.Collections.Generic.IEnumerable{System.String},System.Action{System.Net.HttpWebRequest})">
            <summary>
            上传多文件并且返回标准的HTTP响应
            </summary>
            <param name="url">要将文件上传的目标URL</param>
            <param name="paths">要上文件的文件路径</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>标准响应</returns>
            <remarks>表单域是-----------------------------7de37d0100b78</remarks>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.Upload(System.String,System.String,System.Action{System.Net.HttpWebRequest})">
            <summary>
            上传单文件并且返回标准的HTTP响应
            </summary>
            <param name="url">要将文件上传的目标URL</param>
            <param name="path">要上文件的文件路径</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>标准响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.UploadToPlain(System.String,System.Collections.Generic.IEnumerable{System.String},System.Action{System.Net.HttpWebRequest})">
            <summary>
            上传文件并且返回纯文本响应
            </summary>
            <param name="url">要将文件上传的目标URL</param>
            <param name="paths">要上文件的文件路径</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>纯文本响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.UploadToPlain(System.String,System.String,System.Action{System.Net.HttpWebRequest})">
            <summary>
            上传文件并且返回纯文本响应
            </summary>
            <param name="url">要将文件上传的目标URL</param>
            <param name="path">要上文件的文件路径</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>纯文本响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.UploadToJson(System.String,System.Collections.Generic.List{System.String},System.Action{System.Net.HttpWebRequest})">
            <summary>
            上传文件并且返回JSON响应
            </summary>
            <param name="url">要将文件上传的目标URL</param>
            <param name="paths">要上文件的文件路径</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>JSON响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.UploadToJson(System.String,System.String,System.Action{System.Net.HttpWebRequest})">
            <summary>
            上传文件并且返回JSON响应
            </summary>
            <param name="url">要将文件上传的目标URL</param>
            <param name="path">要上文件的文件路径</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>JSON响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.Download(System.String,System.Action{System.Net.HttpWebRequest})">
            <summary>
            下载文件，返回标准响应
            </summary>
            <param name="url">要下载文件的URL</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>文件的二进制流</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpAccessor.DownloadToBytes(System.String,System.Action{System.Net.HttpWebRequest})">
            <summary>
            下载文件，返回字节流
            </summary>
            <param name="url">要下载文件的URL</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>字节流</returns>
        </member>
        <member name="T:Yunzhi.Net.HttpExtensions">
            <summary>
            一些HTTP相关的扩展工具方法
            </summary>
        </member>
        <member name="M:Yunzhi.Net.HttpExtensions.AddOrSet(System.Net.Http.Headers.HttpHeaders,System.String,System.String)">
            <summary>
            添加或设置HTTP头部键值
            </summary>
            <param name="headers">HTTP头实例</param>
            <param name="name">头部值名称</param>
            <param name="value">值</param>
        </member>
        <member name="M:Yunzhi.Net.HttpExtensions.RemoveIfExists(System.Net.Http.Headers.HttpHeaders,System.String)">
            <summary>
            删除<paramref name="name"/>指定的头，如果存在的话
            </summary>
            <param name="heads">HTTP头实例</param>
            <param name="name">头名称</param>
        </member>
        <member name="M:Yunzhi.Net.HttpExtensions.ReadAsString(System.Net.Http.HttpResponseMessage,System.Text.Encoding)">
            <summary>
            从响应中以同步方式读取文本
            </summary>
            <param name="response">响应实例</param>
            <param name="encoding">以什么编码解析响应文本</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpExtensions.ReadAsJson(System.Net.Http.HttpResponseMessage,System.Text.Encoding)">
            <summary>
            从响应中读取JSON数据
            </summary>
            <param name="response">响应实例</param>
            <param name="encoding">以什么编码解析响应文本</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.Net.HttpWebAccessor">
            <summary>
            一个新的HTTP WEB访问器（客户端）
            </summary>
            <remarks>用于逐步替换<seealso cref="T:Yunzhi.Net.HttpAccessor"/></remarks>
        </member>
        <member name="P:Yunzhi.Net.HttpWebAccessor.DefaultUserAgent">
            <summary>
            获取或设置默认UserAgent
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpWebAccessor.Encoding">
            <summary>
            获取或设置请求和响应编码
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpWebAccessor.EnsureStatusCodeSuccess">
            <summary>
            获取或设置处理响应时是否需要确认响应状态为2xx
            </summary>
            <remarks>用于，有API类服务，将以StatusCode作为请求结果的状态码，可能无法读取响应内容</remarks>
        </member>
        <member name="P:Yunzhi.Net.HttpWebAccessor.ReponseDecompressions">
            <summary>
            获取或设置响应解压缩方式
            默认同时支持<seealso cref="F:System.Net.DecompressionMethods.GZip"/>和<seealso cref="F:System.Net.DecompressionMethods.Deflate"/>
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpWebAccessor.Timeout">
            <summary>
            获取或设置HTTP请求超时时间，单位：秒
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpWebAccessor.Before">
            <summary>
            获取或设置默认的请求前处理行为
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpWebAccessor.UseCookies">
            <summary>
            获取或设置是否要开启cookie功能。
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpWebAccessor.KeepLive">
            <summary>
            获取或设置是否保持与服务器的连接,
            即Connection:keep-live
            </summary>
            <remarks>
            默认为true，即为保持连接，连接同一服务器时有利于提高性能，
            若不是高并发请求可以视情况关闭
            </remarks>
        </member>
        <member name="P:Yunzhi.Net.HttpWebAccessor.Cookies">
            <summary>
            获取当前请求的Cookies，需要将<see cref="P:Yunzhi.Net.HttpWebAccessor.UseCookies"/>设为True
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpWebAccessor.ClientCertificates">
            <summary>
            获取HTTP要携带的证书集合
            </summary>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.#ctor">
            <summary>
            初始化HTTP请求助手
            </summary>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.#ctor(System.Net.Http.HttpMessageHandler)">
            <summary>
            以自定义<seealso cref="T:System.Net.Http.HttpMessageHandler"/>处理程序的方式
            初始化请求助手
            </summary>
            <param name="handler">请求处理程序</param>
            <remarks>
            自定义处理程序如果非<seealso cref="T:System.Net.Http.HttpClientHandler"/>或其子类
            那么<see cref="P:Yunzhi.Net.HttpWebAccessor.UseCookies"/>、 <see cref="P:Yunzhi.Net.HttpWebAccessor.Cookies"/>、<see cref="P:Yunzhi.Net.HttpWebAccessor.ReponseDecompressions"/>、<see cref="P:Yunzhi.Net.HttpWebAccessor.ClientCertificates"/>
            等属性将可能失效，请自行处理相关功能。
            </remarks>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.BuildUrlEncodedData(System.Collections.Generic.IDictionary{System.String,System.String})">
            <summary>
            构建基于URL编码的请求数组
            </summary>
            <param name="parames">请求参数</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.CreateRequest(System.Net.Http.HttpMethod,System.String)">
            <summary>
            创建一个默认的HTTP请求
            </summary>
            <param name="method">请求方法</param>
            <param name="url">请求URL地址</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.CreateRequest(System.Net.Http.HttpMethod,System.String,System.Collections.Generic.IDictionary{System.String,System.String})">
            <summary>
            创建一个带Form域的HTTP请求
            </summary>
            <param name="method">请求方法</param>
            <param name="url">请求URL地址</param>
            <param name="parames">在Body区域携带的表单域参数</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.CreateRequest(System.Net.Http.HttpMethod,System.String,System.Object)">
            <summary>
            创建一个JSON数据的HTTP请求
            </summary>
            <param name="method">请求方法</param>
            <param name="url">请求URL地址</param>
            <param name="data">在Body区域携带的表单域参数</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.CreateRequest(System.Net.Http.HttpMethod,System.String,System.Collections.Generic.IDictionary{System.String,System.String},System.Collections.Generic.IDictionary{System.String,System.String})">
            <summary>
            创建一个带Form域的HTTP请求
            </summary>
            <param name="method">请求方法</param>
            <param name="url">请求URL地址</param>
            <param name="parames">在Body区域携带的表单域参数</param>
            <param name="files">上传文件清单，
            <seealso cref="P:System.Collections.Generic.KeyValuePair`2.Key"/>为上传文件表单域KEY
            <seealso cref="P:System.Collections.Generic.KeyValuePair`2.Value"/>为上传文件路径
            </param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.SendAsyc(System.Net.Http.HttpRequestMessage)">
            <summary>
            异步方式发送一个HTTP请求
            </summary>
            <param name="request">要发送的请求</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.Get(System.String,System.Collections.Generic.IDictionary{System.String,System.String},System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            向<paramref name="url"/>指示的URL发送GET请求，并返回标准响应
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">跟在后面的url参数，默认为空</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>标识响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.GetAsPlain(System.String,System.Collections.Generic.IDictionary{System.String,System.String},System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            向<paramref name="url"/>指示的URL发送GET请求，并返回纯文本响应
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">跟在后面的url参数，默认为空</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>标识响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.GetAsJson(System.String,System.Collections.Generic.IDictionary{System.String,System.String},System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            向<paramref name="url"/>指示的URL发送GET请求，并返回JSON响应
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">跟在后面的url参数，默认为空</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>标识响应</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.Post(System.String,System.Collections.Generic.IDictionary{System.String,System.String},System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            向<paramref name="url"/>指示地址发送一个POST请求
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">要POST表单域参数</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.Post(System.String,System.Object,System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            向<paramref name="url"/>指示地址发送一个JSON格式POST请求
            </summary>
            <param name="url">要请求的URL</param>
            <param name="data">Body区域携带的参数，自动转换为JSON格式数据</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.PostAsPlain(System.String,System.Collections.Generic.IDictionary{System.String,System.String},System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            向<paramref name="url"/>指示地址发送POST请求，并返回响应文本
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">要POST表单域参数</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.PostAsJson(System.String,System.Collections.Generic.IDictionary{System.String,System.String},System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            向<paramref name="url"/>指示地址发送POST请求，并返回JSON响应
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">要POST表单域参数</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.PostAsJson(System.String,System.Object,System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            向<paramref name="url"/>指示地址发送POST请求，并返回JSON响应
            </summary>
            <param name="url">要请求的URL</param>
            <param name="data">Body区域携带的参数，自动转换为JSON格式数据</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.Put(System.String,System.Collections.Generic.IDictionary{System.String,System.String},System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            向<paramref name="url"/>指示地址发送一个POST请求
            </summary>
            <param name="url">要请求的URL</param>
            <param name="parames">要POST表单域参数</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.Put(System.String,System.Object,System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            向<paramref name="url"/>指示地址发送一个JSON格式PUT请求
            </summary>
            <param name="url">要请求的URL</param>
            <param name="data">Body区域携带的参数，自动转换为JSON格式数据</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.Upload(System.String,System.String,System.String,System.Collections.Generic.IDictionary{System.String,System.String},System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            以POST方式上传文件，并返回标准响应
            </summary>
            <param name="url">目前URL</param>
            <param name="key">表单域中上传文件KEY</param>
            <param name="filePath">上传文件路径</param>
            <param name="parames">表单域名非文件域项值</param>
            <param name="before">上传前的自定义动作</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.Upload(System.String,System.Collections.Generic.IDictionary{System.String,System.String},System.Collections.Generic.IDictionary{System.String,System.String},System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            以POST方式上传多个文件，并返回标准响应
            </summary>
            <param name="url">目前URL</param>
            <param name="files">
            要上传的文件清单
            <seealso cref="P:System.Collections.Generic.KeyValuePair`2.Key"/>指示表单域键
            <seealso cref="P:System.Collections.Generic.KeyValuePair`2.Value"/>指示上传文件路径
            </param>
            <param name="parames">表单域名非文件域项值</param>
            <param name="before">上传前的自定义动作</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.Download(System.String,System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            从<paramref name="url"/>指示位置下载二进流
            </summary>
            <param name="url">下载地址</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.DownloadAsBytes(System.String,System.Action{System.Net.Http.HttpRequestMessage})">
            <summary>
            下载文件，返回字节流
            </summary>
            <param name="url">要下载文件的URL</param>
            <param name="before">在发送请求前进行一些个性化操作</param>
            <returns>字节流</returns>
        </member>
        <member name="M:Yunzhi.Net.HttpWebAccessor.Dispose">
            <inheritdoc/>
        </member>
        <member name="T:Yunzhi.Net.HttpWrapper">
            <summary>
            表示一次HTTP过程的包裹
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpWrapper.Request">
            <summary>
            获取或设置本过程的请求
            </summary>
        </member>
        <member name="P:Yunzhi.Net.HttpWrapper.Response">
            <summary>
             获取或设置本过程响应
            </summary>
        </member>
        <member name="M:Yunzhi.Net.HttpWrapper.Dispose">
            <summary>
            释放本次请求的所有资源
            </summary>
        </member>
        <member name="T:Yunzhi.Net.NetSaber">
            <summary>
            跟网络通信相关的工具方法
            </summary>
        </member>
        <member name="M:Yunzhi.Net.NetSaber.GetLocalIPv4">
            <summary>
            获取本机所有IPv4地址
            </summary>
            <returns>IP地址列表</returns>
        </member>
        <member name="M:Yunzhi.Net.NetSaber.GetLocalIPv6">
            <summary>
            获取本机所有IPv4地址
            </summary>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.NetSaber.ReadStringUseUtf8(System.Net.Sockets.NetworkStream,System.Int32)">
            <summary>
            以UTF8编码分段解析网络流
            </summary>
            <param name="bufferSize">缓存区大小,单位Byte</param>
            <param name="stream">要读取的网流</param>
            <returns>流解码后的字符串</returns>
            <remarks>不会拆散汉字</remarks>
        </member>
        <member name="M:Yunzhi.Net.NetSaber.GetUsePorts">
            <summary>
            获取当前系统所有已经使用的端口
            </summary>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.Net.NetSaber.GetFreePort(System.Nullable{System.Int32},System.Nullable{System.Int32})">
            <summary>
            获取一个未被当前系统监听的随机可用端口
            </summary>
            <param name="minPort">指定查找的最小端口</param>
            <param name="maxPort">指定查找的最大端口</param>
            <returns>可以用端口号</returns>
        </member>
        <member name="T:Yunzhi.NoSql.DateOnlySerializer">
            <summary>
            <seealso cref="T:System.DateOnly"/>的BSON序列经器
            </summary>
        </member>
        <member name="M:Yunzhi.NoSql.DateOnlySerializer.Serialize(MongoDB.Bson.Serialization.BsonSerializationContext,MongoDB.Bson.Serialization.BsonSerializationArgs,System.DateOnly)">
            <summary>
            执行<seealso cref="T:System.DateOnly"/>的序列化，序列化为yyyy-MM-dd
            </summary>
            <param name="context">上下文</param>
            <param name="args">序列参数</param>
            <param name="value">日期值</param>
        </member>
        <member name="M:Yunzhi.NoSql.DateOnlySerializer.Deserialize(MongoDB.Bson.Serialization.BsonDeserializationContext,MongoDB.Bson.Serialization.BsonDeserializationArgs)">
            <summary>
            执行<seealso cref="T:System.DateOnly"/>的反序列化
            </summary>
            <param name="context">上下文</param>
            <param name="args">序列参数</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.DateOnlySerializer.Registering">
            <summary>
            将本序列器，注册为全局的<seealso cref="T:System.DateOnly"/>自定义序列化器
            </summary>
        </member>
        <member name="T:Yunzhi.NoSql.DateTimeStorage">
            <summary>
            一个时间存储容器，为解决Mongodb UTC时间转换问题。
            </summary>
        </member>
        <member name="M:Yunzhi.NoSql.DateTimeStorage.Storage(System.String,System.Nullable{System.DateTime})">
            <summary>
            临时存储一个时间，如果<paramref name="val"/>是UTC时间，则转换成本地时间。
            </summary>
            <param name="key">存储唯一键</param>
            <param name="val">存储时间值</param>
        </member>
        <member name="M:Yunzhi.NoSql.DateTimeStorage.Get(System.String)">
            <summary>
            获取指定键存储的时间
            </summary>
            <param name="key">键</param>
            <returns>
            如果没有存储指定键的时间，则返回<seealso cref="T:System.DateTime"/>默认值。
            </returns>
        </member>
        <member name="M:Yunzhi.NoSql.DateTimeStorage.GetNullable(System.String)">
            <summary>
            获取指定键存储的时间
            </summary>
            <param name="key">键</param>
            <returns>
            如果没有存储指定键的时间，则返回null。
            </returns>
        </member>
        <member name="T:Yunzhi.NoSql.Extensions">
            <summary>
            扩展方法
            </summary>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.AutoMaps(MongoDB.Bson.Serialization.BsonClassMap)">
            <summary>
            执行默认映射
            </summary>
            <param name="map">映射实例</param>
            <returns></returns>
            <remarks>
            主要执行<seealso cref="M:MongoDB.Bson.Serialization.BsonClassMap.AutoMap"/>
            和<seealso cref="M:MongoDB.Bson.Serialization.BsonClassMap.SetIgnoreExtraElements(System.Boolean)"/>true
            </remarks>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.FieldName``2(MongoDB.Driver.ProjectionDefinitionBuilder{``0},System.Linq.Expressions.Expression{System.Func{``0,``1}})">
            <summary>
            获取<typeparamref name="TDocument"/>中，<paramref name="field"/>指示属性的BSON文档映射名称
            </summary>
            <typeparam name="TDocument">文档实体类型</typeparam>
            <typeparam name="TField">选择的字段</typeparam>
            <param name="projection">当前<seealso cref="T:MongoDB.Driver.ProjectionDefinitionBuilder`1"/>实例</param>
            <param name="field">字段选择表达式</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.AsBson``1(MongoDB.Driver.FilterDefinition{``0})">
            <summary>
            将<paramref name="filter"/>实例转换成BSON文档
            </summary>
            <typeparam name="TDocument">文档实体类型</typeparam>
            <param name="filter">筛选实例</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.RegexIgnoreCase``1(MongoDB.Driver.FilterDefinitionBuilder{``0},System.String,System.Linq.Expressions.Expression{System.Func{``0,System.Object}})">
            <summary>
            根据<paramref name="searchText"/>搜索字符串，构建一个Regex的不区别大小写搜索筛选
            </summary>
            <param name="builder">当前筛选构建实例</param>
            <param name="searchText">搜索字符串</param>
            <param name="field">字符选择表达式</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.AndIfTrue``1(System.Collections.Generic.IList{MongoDB.Driver.FilterDefinition{``0}},System.Boolean,System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})">
            <summary>
            当满足<paramref name="assert"/>断言条件时，往<paramref name="filters"/>添加<paramref name="predicate"/>的筛选
            用于快速拼接查询表达式
            </summary>
            <typeparam name="TDocument">文档类型</typeparam>
            <param name="filters">筛选表达式集</param>
            <param name="assert">决断表达式，true才会执行<paramref name="predicate"/>筛选，false不执行 </param>
            <param name="predicate">筛选表达式</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.AndIfTrue``1(System.Collections.Generic.IList{MongoDB.Driver.FilterDefinition{``0}},System.String,System.Linq.Expressions.Expression{System.Func{``0,System.Object}})">
            <summary>
            当<paramref name="searchText"/>不为空时，为<paramref name="field"/>字段构建一个不区分大小写的搜索筛选
            用于快速拼接查询表达式
            </summary>
            <typeparam name="TDocument">文档类型</typeparam>
            <param name="filters">筛选表达式集</param>
            <param name="searchText">搜索字符串</param>
            <param name="field">筛选表达式</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.Combine``1(System.Collections.Generic.IEnumerable{MongoDB.Driver.FilterDefinition{``0}})">
            <summary>
            将<paramref name="filters"/>的查询筛选条件，合并成一个<seealso cref="T:MongoDB.Bson.BsonDocument"/>文档，
            即相当于And查询，如果要使用$or连接，请先使用<seealso cref="P:MongoDB.Driver.Builders`1.Filter"/>.Or方法进行连接
            </summary>
            <typeparam name="TDocument">文档实体类型</typeparam>
            <param name="filters">要进行合并的筛选</param>
            <returns>
            如果<paramref name="filters"/>为null或空，则返回一个空Bson
            </returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.FindWithIgnoreCase``1(MongoDB.Driver.IMongoCollection{``0},MongoDB.Driver.FilterDefinition{``0})">
            <summary>
            执行一个忽略大小写的zh查询
            执行查找选项
            <code>
            new Collation("zh", strength: CollationStrength.Primary)
            </code>
            </summary>
            <typeparam name="TDocument">文档类型</typeparam>
            <param name="collection">当前集合实例</param>
            <param name="filter">要执行的筛选</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.FindWithIgnoreCase``1(MongoDB.Driver.IMongoCollection{``0},System.Collections.Generic.IEnumerable{MongoDB.Driver.FilterDefinition{``0}})">
            <summary>
            执行一个忽略大小写的zh查询
            执行查找选项
            <code>
            new Collation("zh", strength: CollationStrength.Primary)
            </code>
            </summary>
            <typeparam name="TDocument">文档类型</typeparam>
            <param name="collection">当前集合实例</param>
            <param name="filters">要执行的筛选集，采用$and接接</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.Pageing``1(MongoDB.Driver.IFindFluent{``0,``0},Yunzhi.Database.Paged)">
            <summary>
            对<paramref name="findFluent"/>查询结果进行分页
            </summary>
            <typeparam name="TDocument">文档实体类型</typeparam>
            <param name="findFluent">接受分页的文档查询结果</param>
            <param name="page">分页设定及分页结果，如果为null，则不进行分页</param>
            <returns>
            如果<paramref name="page"/>不为null,则返回指定页文档
            否则返回结果中的所有文档
            </returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.SetCamelCaseElement(MongoDB.Bson.Serialization.BsonMemberMap)">
            <summary>
            将<paramref name="map"/>映射的BSON元素名改为大写驼峰规则
            </summary>
            <param name="map">BSON成员映射实例</param>
            <returns>
            返回<paramref name="map"/>
            </returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.SetLocalDateTimeSerializer(MongoDB.Bson.Serialization.BsonMemberMap)">
            <summary>
            设定本地日期序化器
            </summary>
            <param name="map">映射实例</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.SetDateOnlySerializer(MongoDB.Bson.Serialization.BsonMemberMap)">
            <summary>
            配置序化为器为<seealso cref="T:Yunzhi.NoSql.DateOnlySerializer"/>
            </summary>
            <param name="map">映射实例</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.SetTimeOnlySerializer(MongoDB.Bson.Serialization.BsonMemberMap)">
            <summary>
            配置序化为器为<seealso cref="T:Yunzhi.NoSql.TimeOnlySerializer"/>
            </summary>
            <param name="map">映射实例</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.SetGisCoordinateSerializer(MongoDB.Bson.Serialization.BsonMemberMap)">
            <summary>
            设定<seealso cref="T:Yunzhi.Common.GisCoordinate"/>成员的序列化器为<seealso cref="T:Yunzhi.NoSql.GisCoordinateSerializer"/>
            </summary>
            <param name="map">映射实例</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.Extensions.ParseToGeoJsonPoint(Yunzhi.Common.GisCoordinate)">
            <summary>
            将当前<seealso cref="T:Yunzhi.Common.GisCoordinate"/>坐标转换成<seealso cref="T:MongoDB.Driver.GeoJsonObjectModel.GeoJsonObject`1"/>点
            </summary>
            <param name="coordinate">当前坐标实例</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.NoSql.GisCoordinateSerializer">
            <summary>
            地理坐标序列化器
            将<seealso cref="T:Yunzhi.Common.GisCoordinate"/>与<seealso cref="T:MongoDB.Driver.GeoJsonObjectModel.GeoJsonPoint`1"/>结果的互序列
            </summary>
        </member>
        <member name="M:Yunzhi.NoSql.GisCoordinateSerializer.Serialize(MongoDB.Bson.Serialization.BsonSerializationContext,MongoDB.Bson.Serialization.BsonSerializationArgs,Yunzhi.Common.GisCoordinate)">
            <summary>
            执行<seealso cref="T:Yunzhi.Common.GisCoordinate"/>的序列化
            </summary>
            <param name="context">上下文</param>
            <param name="args">序列参数</param>
            <param name="value">地理信息值</param>
        </member>
        <member name="M:Yunzhi.NoSql.GisCoordinateSerializer.Deserialize(MongoDB.Bson.Serialization.BsonDeserializationContext,MongoDB.Bson.Serialization.BsonDeserializationArgs)">
            <summary>
            执行<seealso cref="T:Yunzhi.Common.GisCoordinate"/>的反序列化
            </summary>
            <param name="context">上下文</param>
            <param name="args">序列参数</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.GisCoordinateSerializer.Registering">
            <summary>
            将本序列器，注册为全局的<seealso cref="T:Yunzhi.Common.GisCoordinate"/>和<seealso cref="T:System.Nullable`1"/>自定义序列化器
            </summary>
        </member>
        <member name="T:Yunzhi.NoSql.MongoDbAccess">
            <summary>
            MongoDb数据库访问器
            </summary>
            <remarks>
            连接字符串建以mongo://[user:password@]host:port/形式输入，此为标识mogodb连接字符
            如果要指定连接数据库mongo://[user:password@]host:port/[database]形式设置；
            </remarks>
        </member>
        <member name="P:Yunzhi.NoSql.MongoDbAccess.Client">
            <summary>
            获取当前连接的MongoDb客户端
            </summary>
        </member>
        <member name="P:Yunzhi.NoSql.MongoDbAccess.Database">
            <summary>
            获取当前连接的MongoDb的数据库
            </summary>
        </member>
        <member name="P:Yunzhi.NoSql.MongoDbAccess.ConnectionString">
            <summary>
            获取当前的连接字符串
            </summary>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbAccess.#ctor(System.String,System.String)">
            <summary>
            初始化一个访问器
            </summary>
            <param name="connstr">连接字符串，如果以{connstrName}形式传入，将自动取配置文件连接字符串；</param>
            <param name="datebase">数据库名称，如果<paramref name="connstr"/>没有指定连接数据库，此必须在此参数中指定连接数据库；如果同时指定本参数优先；</param>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbAccess.GetCollectionAccess``1(System.String)">
            <summary>
            获取当前数据库下的指定集合访问器
            </summary>
            <typeparam name="T">集合存储元素类型</typeparam>
            <param name="name">集合名换</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbAccess.RegisterClassBsonMap``1(System.Action{MongoDB.Bson.Serialization.BsonClassMap{``0}},System.Boolean)">
            <summary>
            注册BSON序列映射，默认如果已经配置则执行新配置
            </summary>
            <param name="config">执行配置委托</param>
            <param name="force">如果已经配置映射是否再次执行一次当前配置</param>
            <typeparam name="T">要配置映射的类型</typeparam>
        </member>
        <member name="T:Yunzhi.NoSql.MongoDbCollectionAccess`1">
            <summary>
            MongoDB集合访问器
            </summary>
            <typeparam name="T">集合存储类型</typeparam>
        </member>
        <member name="P:Yunzhi.NoSql.MongoDbCollectionAccess`1.Database">
            <summary>
            获取当前操作的数据库
            </summary>
        </member>
        <member name="P:Yunzhi.NoSql.MongoDbCollectionAccess`1.Collection">
            <summary>
            获取当前操作的集合原生Mongodb引用
            </summary>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.#ctor(MongoDB.Driver.IMongoDatabase,System.String)">
            <summary>
            初始化当前集合访问器
            </summary>
            <param name="db">集合所有的数据库</param>
            <param name="collName">集合名称</param>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.#ctor(MongoDB.Driver.IMongoCollection{`0})">
            <summary>
            初始化集合访问器
            </summary>
            <param name="collection">Mongodb集合实例</param>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Add(`0)">
            <summary>
            向集合添加文档对象
            </summary>
            <param name="doc">要添加的文档</param>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Add(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            向集合批量添加文档对象
            </summary>
            <param name="docs">要添加的文档集</param>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Insert(`0)">
            <summary>
            向集合添加文档对象
            </summary>
            <param name="doc">要添加的文档</param>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Insert(System.Collections.Generic.IEnumerable{`0})">
            <summary>
            向集合批量添加文档对象
            </summary>
            <param name="docs">要添加的文档集</param>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Update(`0,MongoDB.Driver.FilterDefinition{`0})">
            <summary>
            以替换的方式更新集合中存在的文档
            </summary>
            <param name="doc">要更新的文档</param>
            <param name="filter">要替换文档的筛选条件</param>
            <returns>被修改的条数</returns>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Update(`0,System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
            <summary>
            以替换的方式更新集合中存在的文档
            </summary>
            <param name="doc">要更新的文档</param>
            <param name="filter">要替换文档的筛选条件</param>
            <returns>被修改的条数</returns>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Delete(MongoDB.Driver.FilterDefinition{`0})">
            <summary>
            删除集合中的文档
            </summary>
            <param name="filter">筛选条件</param>
            <returns>被删除的条数</returns>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Delete(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
            <summary>
            删除集合中的文档
            </summary>
            <param name="filter">筛选条件</param>
            <returns>被删除的条数</returns>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Get(MongoDB.Driver.FilterDefinition{`0},System.Boolean)">
            <summary>
            获取集合中的单个文档
            </summary>
            <param name="filter">筛选条件</param>
            <param name="excludeId">是否排除内部唯一键_id</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Get(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}},System.Boolean)">
            <summary>
            获取集合中的单个文档
            </summary>
            <param name="filter">筛选条件</param>
            <param name="excludeId">是否排除内部唯一键_id</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Search(MongoDB.Driver.FilterDefinition{`0},Yunzhi.Database.Paged,System.Boolean)">
            <summary>
            搜索集合中的文档
            </summary>
            <param name="filter">筛选条件</param>
            <param name="page">分页设定及结果</param>
            <param name="excludeId">是否排除内部唯一键_id</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Search(System.Collections.Generic.IEnumerable{MongoDB.Driver.FilterDefinition{`0}},Yunzhi.Database.Paged,System.Boolean)">
            <summary>
            搜索集合中的文档
            </summary>
            <param name="filters">筛选条件，多个以AND方式连接，为null或者空是搜索全部</param>
            <param name="page">分页设定及结果</param>
            <param name="excludeId">是否排除内部唯一键_id</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.MongoDbCollectionAccess`1.Search(System.Collections.Generic.IEnumerable{System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}}},Yunzhi.Database.Paged,System.Boolean)">
            <summary>
            搜索集合中的文档
            </summary>
            <param name="filters">筛选条件，多个以AND方式连接，为null或者空是搜索全部</param>
            <param name="page">分页设定及结果</param>
            <param name="excludeId">是否排除内部唯一键_id</param>
            <returns></returns>
        </member>
        <member name="T:Yunzhi.NoSql.TimeOnlySerializer">
            <summary>
            <seealso cref="T:System.TimeOnly"/>的BSON序列经器
            </summary>
            <remarks>
            将时间存储为1HHmmss，如1001232整数，期中前导1为补位数字，防止00:00:12格式。
            注意会损失毫秒以后的精度。
            </remarks>
        </member>
        <member name="M:Yunzhi.NoSql.TimeOnlySerializer.Serialize(MongoDB.Bson.Serialization.BsonSerializationContext,MongoDB.Bson.Serialization.BsonSerializationArgs,System.TimeOnly)">
            <summary>
            执行<seealso cref="T:System.TimeOnly"/>的序列化，序列化为HHmmss
            </summary>
            <param name="context">上下文</param>
            <param name="args">序列参数</param>
            <param name="value">时间值</param>
        </member>
        <member name="M:Yunzhi.NoSql.TimeOnlySerializer.Deserialize(MongoDB.Bson.Serialization.BsonDeserializationContext,MongoDB.Bson.Serialization.BsonDeserializationArgs)">
            <summary>
            执行<seealso cref="T:System.TimeOnly"/>的反序列化
            </summary>
            <param name="context">上下文</param>
            <param name="args">序列参数</param>
            <returns></returns>
        </member>
        <member name="M:Yunzhi.NoSql.TimeOnlySerializer.Registering">
            <summary>
            将本序列器，注册为全局的<seealso cref="T:System.TimeOnly"/>自定义序列化器
            </summary>
        </member>
        <member name="T:Yunzhi.Security.BigInteger">
            <summary>
            用于加密运算的大整数，引用至第三方
            </summary>
        </member>
        <member name="T:Yunzhi.Security.EncryptSaber">
            <summary>
            加解密服务工具类
            </summary>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.ToHex(System.Byte[])">
            <summary>
            将字节流转换成十六进制字符串
            </summary>
            <param name="bytes">要转换的字节流</param>
            <returns>转换后的十六进制字符串</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.MD5(System.String)">
            <summary>
            将字符串进行MD5加密
            </summary>
            <param name="input">要加密的字符串</param>
            <returns>input加密后的字符串</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.RandomChars(System.Int32)">
            <summary>
            生成一个指定长度的随机字符串
            </summary>
            <param name="length">要生成的长度</param>
            <returns>生成好的字符串</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.Hash(System.Byte[],System.String)">
            <summary>
            计算指定字节流的哈希值
            </summary>
            <param name="bytes">要计算哈希值的字节流</param>
            <param name="hashName">哈希算法名称，可选SHA1 SHA256 SHA384 SHA512 MD5</param>
            <returns>哈希值的十六进字符串</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.Hash(System.IO.Stream,System.String)">
            <summary>
            计算指定二进制流的哈希值
            </summary>
            <param name="stream">要计算哈希值的二进制流</param>
            <param name="hashName">哈希算法名称，可选SHA1 SHA256 SHA384 SHA512 MD5</param>
            <returns>哈希值的十六进字符串</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.Hash(System.String,System.String)">
            <summary>
            计算指定文本的哈希值
            </summary>
            <param name="text">要计算哈希值文本</param>
            <param name="hashName">哈希算法名称，可选SHA1 SHA256 SHA384 SHA512 MD5</param>
            <returns>哈希值的十六进字符串</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.EncryptText(System.String,System.Security.Cryptography.SymmetricAlgorithm)">
            <summary>
            用指定的key对plninText的明文进行加加密
            </summary>
            <param name="plainText">需求加密的明文</param>
            <param name="key">加密密钥</param>
            <returns>返回加密后的文本</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.EncryptText(System.String,System.String)">
            <summary>
            采用AES算法使用<paramref name="key"/>的MD5值作为密钥，对<paramref name="plainText"/>进行加密。
            </summary>
            <param name="plainText">要加的明文</param>
            <param name="key">加密的密钥文本</param>
            <returns>加密流的Base64形式</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.DecryptText(System.Byte[],System.Security.Cryptography.SymmetricAlgorithm)">
            <summary>
            使用key对cypherText的解密
            </summary>
            <param name="cypherText">要解密的字符串</param>
            <param name="key">加密CypherText的密钥</param>
            <returns>返回解密后的字符串</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.DecryptText(System.String,System.String)">
            <summary>
            使用AES算法采用<paramref name="key"/>作为密钥对<paramref name="ciphertext"/>进行解密。
            </summary>
            <param name="ciphertext">要解密的密文</param>
            <param name="key">解密的文本key</param>
            <returns>解密的原文文本</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.RSAEncryptText(System.String,Yunzhi.Security.BigInteger,Yunzhi.Security.BigInteger,System.Text.Encoding)">
            <summary>
            用指定的私钥(n,d)加密指定文本source
            </summary>
            <param name="source">要加密的文本</param>
            <param name="d">对应RSA密钥中的D</param>
            <param name="n">对应RSA密钥中的Modulus</param>
            <param name="encoding">采用何种编码进行二进制转换(默认UTF8)</param>
            <returns>加密后的文本</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.RSAEncryptText(System.String,System.Byte[],System.Byte[],System.Text.Encoding)">
            <summary>
            用指定的私钥(n,d)加密指定文本source
            </summary>
            <param name="source">要加密的文本</param>
            <param name="d">对应RSA密钥中的D</param>
            <param name="n">对应RSA密钥中的Modulus</param>
            <param name="encoding">采用何种编码进行二进制转换(默认UTF8)</param>
            <returns>加密后的文本</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.RSADecryptText(System.String,Yunzhi.Security.BigInteger,Yunzhi.Security.BigInteger,System.Text.Encoding)">
            <summary>
            用指定的公钥(n,e)解密指定字符串source
            </summary>
            <param name="source">要解密的文本</param>
            <param name="e">对应RSA密钥中的Exponent</param>
            <param name="n">对应RSA密钥中的Modulus</param>
            <param name="encoding">采用何种编码对解密后的流生成字符串</param>
            <returns>解密后的明文</returns>
        </member>
        <member name="M:Yunzhi.Security.EncryptSaber.RSADecryptText(System.String,System.Byte[],System.Byte[],System.Text.Encoding)">
            <summary>
            用指定的公钥(n,e)解密指定字符串source
            </summary>
            <param name="source">要解密的文本</param>
            <param name="e">对应RSA密钥中的Exponent</param>
            <param name="n">对应RSA密钥中的Modulus</param>
            <param name="encoding">采用何种编码对解密后的流生成字符串</param>
            <returns>解密后的明文</returns>
        </member>
    </members>
</doc>