Full Code of NewLifeX/NewLife.RocketMQ for AI

Repository: NewLifeX/NewLife.RocketMQ
Branch: master
Commit: 88a51ffbfe13
Files: 140
Total size: 1.3 MB

Directory structure:
gitextract_ldvbuhvt/

├── .editorconfig
├── .gitattributes
├── .github/
│   ├── copilot-instructions.md
│   ├── instructions/
│   │   ├── benchmark.instructions.md
│   │   ├── development.instructions.md
│   │   └── net.instructions.md
│   └── workflows/
│       ├── publish-beta.yml
│       ├── publish.yml
│       └── test.yml
├── .gitignore
├── ChangeLog.md
├── DLL/
│   ├── NewLife.Core.xml
│   └── NewLife.RocketMQ.xml
├── Doc/
│   ├── Changelog.md
│   ├── RequestReply_Guide.md
│   ├── newlife.snk
│   ├── rmq_4.9.7.pcap
│   ├── 架构设计.md
│   └── 需求文档.md
├── LICENSE
├── NewLife.RocketMQ/
│   ├── .github/
│   │   └── copilot-instructions.md
│   ├── AclOptions.cs
│   ├── AclProvider.cs
│   ├── AliyunOptions.cs
│   ├── AliyunProvider.cs
│   ├── BrokerClient.cs
│   ├── ClusterClient.cs
│   ├── Common/
│   │   ├── BrokerInfo.cs
│   │   ├── ILoadBalance.cs
│   │   └── WeightRoundRobin.cs
│   ├── Consumer.cs
│   ├── Grpc/
│   │   ├── GrpcClient.cs
│   │   ├── GrpcEnums.cs
│   │   ├── GrpcMessagingService.cs
│   │   ├── GrpcModels.cs
│   │   ├── GrpcServiceMessages.cs
│   │   └── ProtoExtensions.cs
│   ├── Helper.cs
│   ├── HuaweiProvider.cs
│   ├── ICloudProvider.cs
│   ├── MessageTrace/
│   │   ├── AsyncTraceDispatcher.cs
│   │   ├── MessageTraceHook.cs
│   │   └── TraceModel.cs
│   ├── Models/
│   │   ├── ConsumeEventArgs.cs
│   │   ├── ConsumeFromWheres.cs
│   │   ├── ConsumeTypes.cs
│   │   ├── DelayTimeLevels.cs
│   │   └── MessageModels.cs
│   ├── MqBase.cs
│   ├── MqSetting.cs
│   ├── NameClient.cs
│   ├── NewLife.RocketMQ.csproj
│   ├── Producer.cs
│   ├── Properties/
│   │   └── PublishProfiles/
│   │       └── FolderProfile.pubxml
│   ├── Protocol/
│   │   ├── Command.cs
│   │   ├── ConsumerData.cs
│   │   ├── ConsumerRunningInfo.cs
│   │   ├── ConsumerStates/
│   │   │   ├── ConsumerStatesModel.cs
│   │   │   ├── MessageQueueModel.cs
│   │   │   └── OffsetWrapperModel.cs
│   │   ├── EndTransactionRequestHeader.cs
│   │   ├── Header.cs
│   │   ├── HeartbeatData.cs
│   │   ├── LanguageCode.cs
│   │   ├── MQVersion.cs
│   │   ├── Message.cs
│   │   ├── MessageExt.cs
│   │   ├── MessageQueue.cs
│   │   ├── MqCodec.cs
│   │   ├── ProducerData.cs
│   │   ├── PullMessageRequestHeader.cs
│   │   ├── PullResult.cs
│   │   ├── QueryResult.cs
│   │   ├── RequestCode.cs
│   │   ├── ResponseCode.cs
│   │   ├── ResponseException.cs
│   │   ├── SendMessageRequestHeader.cs
│   │   ├── SendResult.cs
│   │   ├── SendStatus.cs
│   │   ├── SerializeType.cs
│   │   ├── ServiceState.cs
│   │   ├── SubscriptionData.cs
│   │   └── TransactionState.cs
│   └── TencentProvider.cs
├── NewLife.RocketMQ.sln
├── Readme.MD
├── Test/
│   ├── Program.cs
│   └── Test.csproj
└── XUnitTestRocketMQ/
    ├── .github/
    │   └── copilot-instructions.md
    ├── AliyunIssuesTests.cs
    ├── AliyunTests.cs
    ├── BasicTest.cs
    ├── BatchAckTests.cs
    ├── BatchMessageTests.cs
    ├── BroadcastOffsetTests.cs
    ├── BrokerFailoverTests.cs
    ├── BrokerInfoTests.cs
    ├── CloudProviderTests.cs
    ├── CommandTests.cs
    ├── CompressionTests.cs
    ├── ConcurrentConsumeTests.cs
    ├── ConsumeStatsTests.cs
    ├── ConsumerStatesModelTests.cs
    ├── ConsumerTests.cs
    ├── HeaderTests.cs
    ├── IPv6Tests.cs
    ├── MQVersionTests.cs
    ├── MQVersionUpdateTests.cs
    ├── ManagementTests.cs
    ├── MessageExtendedTests.cs
    ├── MessageId5xTests.cs
    ├── MessageQueueTests.cs
    ├── MessageTests.cs
    ├── MessageTraceTests.cs
    ├── ModelTests.cs
    ├── MqBasePropertyTests.cs
    ├── MqSettingTests.cs
    ├── MultiTopicTests.cs
    ├── NameClientTests.cs
    ├── OrderConsumeTests.cs
    ├── PopConsumeTests.cs
    ├── ProducerTests.cs
    ├── ProducerTracerTests.cs
    ├── ProtoTests.cs
    ├── ProtocolDataTests.cs
    ├── PullResultTests.cs
    ├── QueryMessageTests.cs
    ├── RequestHeaderTests.cs
    ├── RequestReplyTests.cs
    ├── ResponseExceptionTests.cs
    ├── RetryTests.cs
    ├── SQL92FilterTests.cs
    ├── SendResultTests.cs
    ├── SpanRefactorTests.cs
    ├── SupportApacheAclTest.cs
    ├── TraceModelTests.cs
    ├── TransactionCheckTests.cs
    ├── VipChannelTests.cs
    ├── WeightRoundRobinTests.cs
    └── XUnitTestRocketMQ.csproj

================================================
FILE CONTENTS
================================================

================================================
FILE: .editorconfig
================================================
# EditorConfig is awesome:http://EditorConfig.org
# https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference

# top-most EditorConfig file
root = true

# Don't use tabs for indentation.
[*]
indent_style = space
# (Please don't specify an indent_size here; that has too many unintended consequences.)

# Code files
[*.{cs,csx,vb,vbx}]
indent_size = 4
insert_final_newline = false
charset = utf-8-bom
end_of_line = crlf

# Xml project files
[*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,projitems,shproj}]
indent_size = 2

# Xml config files
[*.{props,targets,ruleset,config,nuspec,resx,vsixmanifest,vsct}]
indent_size = 2

# JSON files
[*.json]
indent_size = 2

# Dotnet code style settings:
[*.{cs,vb}]
# Sort using and Import directives with System.* appearing first
dotnet_sort_system_directives_first = true

csharp_indent_case_contents = true
csharp_indent_switch_labels = true
csharp_indent_labels = flush_left

#csharp_space_after_cast = true
#csharp_space_after_keywords_in_control_flow_statements = true
#csharp_space_between_method_declaration_parameter_list_parentheses = true
#csharp_space_between_method_call_parameter_list_parentheses = true
#csharp_space_between_parentheses = control_flow_statements, type_casts

# 单行放置代码
csharp_preserve_single_line_statements = true
csharp_preserve_single_line_blocks = true

# Avoid "this." and "Me." if not necessary
dotnet_style_qualification_for_field = false:warning
dotnet_style_qualification_for_property = false:warning
dotnet_style_qualification_for_method = false:warning
dotnet_style_qualification_for_event = false:warning

# Use language keywords instead of framework type names for type references
dotnet_style_predefined_type_for_locals_parameters_members = false:suggestion
dotnet_style_predefined_type_for_member_access = false:suggestion
#dotnet_style_require_accessibility_modifiers = for_non_interface_members:none/always:suggestion

# Suggest more modern language features when available
dotnet_style_object_initializer = true:suggestion
dotnet_style_collection_initializer = true:suggestion
dotnet_style_coalesce_expression = true:suggestion
dotnet_style_null_propagation = true:suggestion
dotnet_style_explicit_tuple_names = true:suggestion
dotnet_style_prefer_inferred_tuple_names = true:suggestion
dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion

# CSharp code style settings:
[*.cs]
# Prefer "var" everywhere
csharp_style_var_for_built_in_types = true:warning
csharp_style_var_when_type_is_apparent = true:warning
csharp_style_var_elsewhere = true:warning

# Prefer method-like constructs to have a block body
csharp_style_expression_bodied_methods = when_on_single_line:suggestion
csharp_style_expression_bodied_constructors = when_on_single_line:suggestion
csharp_style_expression_bodied_operators = when_on_single_line:suggestion

# Prefer property-like constructs to have an expression-body
csharp_style_expression_bodied_properties = true:suggestion
csharp_style_expression_bodied_indexers = true:suggestion
#csharp_style_expression_bodied_accessors = true:suggestion

# Suggest more modern language features when available
csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion
csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
csharp_style_inlined_variable_declaration = true:suggestion

csharp_prefer_simple_default_expression = true:suggestion
csharp_style_deconstructed_variable_declaration = true:suggestion
csharp_style_pattern_local_over_anonymous_function = true:suggestion

csharp_style_throw_expression = true:suggestion
csharp_style_conditional_delegate_call = true:suggestion

# 单行不需要大括号
csharp_prefer_braces = false:suggestion

# Newline settings
csharp_new_line_before_open_brace = all
csharp_new_line_before_else = true
csharp_new_line_before_catch = true
csharp_new_line_before_finally = true
csharp_new_line_before_members_in_object_initializers = true
csharp_new_line_before_members_in_anonymous_types = true
csharp_new_line_between_query_expression_clauses = true

[*.md]
trim_trailing_whitespace = false

================================================
FILE: .gitattributes
================================================
###############################################################################
# Set default behavior to automatically normalize line endings.
###############################################################################
* text=auto

###############################################################################
# Set default behavior for command prompt diff.
#
# This is need for earlier builds of msysgit that does not have it on by
# default for csharp files.
# Note: This is only used by command line
###############################################################################
#*.cs     diff=csharp

###############################################################################
# Set the merge driver for project and solution files
#
# Merging from the command prompt will add diff markers to the files if there
# are conflicts (Merging from VS is not affected by the settings below, in VS
# the diff markers are never inserted). Diff markers may cause the following 
# file extensions to fail to load in VS. An alternative would be to treat
# these files as binary and thus will always conflict and require user
# intervention with every merge. To do so, just uncomment the entries below
###############################################################################
#*.sln       merge=binary
#*.csproj    merge=binary
#*.vbproj    merge=binary
#*.vcxproj   merge=binary
#*.vcproj    merge=binary
#*.dbproj    merge=binary
#*.fsproj    merge=binary
#*.lsproj    merge=binary
#*.wixproj   merge=binary
#*.modelproj merge=binary
#*.sqlproj   merge=binary
#*.wwaproj   merge=binary

###############################################################################
# behavior for image files
#
# image files are treated as binary by default.
###############################################################################
#*.jpg   binary
#*.png   binary
#*.gif   binary

###############################################################################
# diff behavior for common document formats
# 
# Convert binary document formats to text before diffing them. This feature
# is only available from the command line. Turn it on by uncommenting the 
# entries below.
###############################################################################
#*.doc   diff=astextplain
#*.DOC   diff=astextplain
#*.docx  diff=astextplain
#*.DOCX  diff=astextplain
#*.dot   diff=astextplain
#*.DOT   diff=astextplain
#*.pdf   diff=astextplain
#*.PDF   diff=astextplain
#*.rtf   diff=astextplain
#*.RTF   diff=astextplain


================================================
FILE: .github/copilot-instructions.md
================================================
# NewLife Copilot 协作指令

适用于 NewLife 系列全部 C#/.NET 仓库，本文件可随仓库/指令目录一起拷贝到其他项目直接复用。存在本文件则必须遵循。**简体中文回复。**
通用 C# 最佳实践（设计模式、SOLID、健壮性等）AI 已知，此处不赘述，**仅列出组织专属规则与反常规约定**。

---

## 1. 专用指令（前置检查，必须执行）

**开始任何任务前，必须先将用户请求与下表触发信号逐行匹配。命中则立即用 `get_file` 读取 `.github/instructions/{指令文件}`，读取成功后遵循其中全部规则。未命中任何行才跳过。**

| 触发信号（用户请求含以下任意关键词即命中） | 指令文件 |
|---------|---------|
| XCode/实体生成/Model.xml/数据库 CRUD/`NewLife.XCode` 引用/`*.xcode.xml`/项目名含 `.Data`/`XCode.*` 命名空间/用户提及修改任意 `.xml` 文件 | `xcode.instructions.md` |
| Cube/魔方/Web开发/`NewLife.Cube` 引用/`NewLife.Cube.*` 命名空间 | `cube.instructions.md` |
| 性能测试/基准测试/压力测试/压测/BenchmarkDotNet/Benchmark/benchmark/吞吐量评估/性能分析/性能对比/性能报告/速度对比/速度测试/内存分配/perf/性能优化测试/做性能/跑分/测试报告 | `benchmark.instructions.md` |
| NetServer/NetSession/网络服务器/网络客户端/Socket服务/TCP服务/UDP服务/`NewLife.Net` 引用/`NewLife.Net.*` 命名空间/ISocketClient/ISocketRemote/CreateRemote/StandardCodec/LengthFieldCodec/管道编解码/网络编程/Echo服务/网络会话/长连接/粘包拆包 | `net.instructions.md` |
| 新建系统/新建项目/新增模块/需求整理/需求文档/需求分析/架构设计/技术方案/功能清单/功能拆分/任务分解/迭代开发/迭代计划/验收/PRD/用户故事/做一个系统/做一个平台/开发流程/全部搞完/批量开发/自治模式/一次性做完/继续处理/接着做 | `development.instructions.md` |
| 缓存/ICache/MemoryCache/Redis缓存/ICacheProvider/缓存设计/`NewLife.Caching` 命名空间 | `caching.instructions.md` |
| 序列化/JSON/Binary/JsonHelper/序列化设计/SpanSerializer/CSV导出/`NewLife.Serialization` 命名空间 | `serialization.instructions.md` |
| 加密/安全/Hash/MD5/SHA/AES/SM4/RSA/JWT/SecurityHelper/TokenProvider/`NewLife.Security` 命名空间 | `security.instructions.md` |
| 远程调用/ApiHttpClient/ApiClient/ApiServer/负载均衡/LoadBalancer/RPC/HTTP客户端/`NewLife.Remoting` 命名空间 | `remoting.instructions.md` |
| 配置/Config/IConfigProvider/HttpConfigProvider/CommandParser/配置中心/`NewLife.Configuration` 命名空间 | `configuration.instructions.md` |

**自动匹配指令**（无需触发，按 `applyTo` 路径自动生效）：`caching`、`serialization`、`security`、`remoting`、`configuration` 这 5 个指令文件同时配置了 `applyTo` 模式，编辑对应目录下的文件时 VS Code 会自动加载。

---

## 2. 核心原则

检索优先、风格一致、兼容友好、**主动优化**。
发现明显缺陷（资源泄漏、空引用、逻辑错误）时主动修复；优化请求时深入分析，不做表面工作。
改动较小直接做并说明；改动较大（涉及公共 API 或大范围重构）先列方案询问确认。

---

## 3. 兼容性约束（极重要）

- **语言版本**：当前为 **C# 14**（`<LangVersion>latest</LangVersion>`），最大化使用最新语法糖（switch 表达式、集合表达式 `[]`、`?.`/`??`/`??=`、模式匹配、目标类型 `new`、record 等）
- **框架版本**：新增 API 前，先查看当前项目 `.csproj` 的 `<TargetFrameworks>` 配置，**只需满足已声明版本的兼容性**，无需对所有历史版本降级。若包含 `net45`/`netstandard2.0` 等低版本，再提供条件编译降级实现。
- **禁止高版本专属 BCL API**（低版本项目）：❌ `ArgumentNullException.ThrowIfNull()` → ✅ `if (x == null) throw new ArgumentNullException(nameof(x));`
- **条件编译符号**：`NETFRAMEWORK`、`NETSTANDARD2_0`、`NETCOREAPP`、`NET5_0_OR_GREATER`、`NET6_0_OR_GREATER`、`NET8_0_OR_GREATER`

---

## 4. 编码规范

### 4.1 类型名（关键差异）

**必须**使用 .NET 正式名：`String`/`Int32`/`Boolean`/`Int64`/`Double`/`Object` 等。
❌ **禁止**使用 C# 别名：`string`/`int`/`bool`/`long`/`double`/`object`

### 4.2 命名

| 成员类型 | 规则 | 示例 |
|---------|------|------|
| 类型/公共成员 | PascalCase | `UserService`、`GetName()` |
| 参数/局部变量 | camelCase | `userName`、`count` |
| 私有字段 | `_camelCase` | `_cache`、`_instance` |
| 扩展方法类 | `xxxHelper` 或 `xxxExtensions` | `StringHelper`、`CollectionExtensions` |

### 4.3 代码风格

- **命名空间**：file-scoped namespace
- **单文件**：每文件一个主要公共类型；较大平台差异使用 `partial`
- **集合初始化**：优先使用集合表达式 `[]`，如 `List<String> Tags { get; set; } = [];`
- **Null 条件运算符**：优先使用 `?.`/`??` 简化空值检查；**C# 14 空条件赋值 `??=`**：变量为 null 时才赋值，可显著提升可读性

```csharp
// ✅ C#14 空条件赋值（??=）：为 null 时才赋值，替代 if (x == null) x = ...
_cache ??= new MemoryCache();
list ??= [];

// ✅ if 内只有单行代码时可不加花括号（单行 if 同行或换行均可）
if (value == null) return;
if (key == null) throw new ArgumentNullException(nameof(key));

// ✅ 语句较长时另起一行，仍不加花括号
if (value == null)
    throw new ArgumentNullException(nameof(value), "Value cannot be null");

// ✅ 多分支单语句：不加花括号
if (count > 0)
    DoSomething();
else
    DoOther();

// ✅ for/foreach/while 循环体必须保留花括号（即使单语句）
foreach (var item in list)
{
    Process(item);
}

for (var i = 0; i < count; i++)
{
    Process(i);
}

// ✅ using 优先无花括号声明；仅需生命周期（如锁）时用弃元
using var stream = File.OpenRead("file.txt");
using var _ = _lock.AcquireLock();
```

### 4.4 Region 与日志

较长类使用 `#region` 分段，顺序：`属性` → `静态` → `构造` → `方法` → `辅助` → **`日志`**。
含 `ILog Log` 和 `WriteLog` 时：**必须放类末尾**，用名为"日志"的 region 包裹，不放入"辅助"。
关键过程可使用 `Tracer?.NewSpan()` 埋点。

### 4.5 文档注释

- `<summary>` **必须同行闭合**：`/// <summary>获取名称</summary>`
- 每个参数**必须有** `<param>` 标签，无论方法可见性
- 有返回值**必须有** `<returns>`；复杂方法可增加 `<remarks>`
- `public`/`protected` 成员必须注释；`[Obsolete]` 必须包含迁移建议

### 4.6 异步与性能

- 异步方法后缀 `Async`，库内部默认 `ConfigureAwait(false)`
- 热点路径避免反射/复杂 Linq，优先手写循环/`ArrayPool<T>`/`Span`
- 池化资源明确获取/归还，异常分支不遗失归还

### 4.7 错误处理

- 精准异常类型：`ArgumentNullException`/`InvalidOperationException` 等
- TryXxx 模式：不用异常作常规分支
- 类型转换：优先使用 `Utility` 扩展方法，完整列表：`ToInt()`/`ToLong()`/`ToDouble()`/`ToDecimal()`/`ToBoolean()`/`ToDateTime()`/`ToDateTimeOffset()`
- 对外异常不暴露内部实现/路径

---

## 5. NewLife 内置工具

优先使用项目内置工具而非标准库，**禁止重复造轮子**：

- 字符串构建：`Pool.StringBuilder`（替代 `new StringBuilder()`）
- 时间戳（毫秒级相对时间）：`Runtime.TickCount64`；**代码计时（精确耗时测量）：`Stopwatch`**
- 类型转换：`Utility` 扩展方法 — `ToInt()`/`ToLong()`/`ToDouble()`/`ToDecimal()`/`ToBoolean()`/`ToDateTime()`/`ToDateTimeOffset()`
- 二进制读写：`SpanReader` / `SpanWriter`（替代手动字节偏移操作）
- 追踪埋点：`Tracer?.NewSpan()`

---

## 6. 防御性注释（禁止删除）

代码中带有说明文字的被注释代码属于**防御性注释**，记录历史踩坑经验。**禁止删除，禁止"恢复"执行**。可补充更详细说明。

```csharp
// 曾经尝试过同步等待，但会导致线程池饥饿和死锁
// var result = task.Result;

// 不要使用 SendAsync 的无超时重载，否则会造成连接泄漏
// await client.SendAsync(data);
```

---

## 7. 工作流

触发检查（第 1 节触发信号表匹配，命中则读取专用指令） → 检索（**优先复用**现有实现） → 评估（公共 API/兼容性/性能） → 方案 → 实施 → 验证 → **AskQuestions 多选确认** → [需调整则循环] → 说明

- **触发检查**：开始工作前必须完成，遗漏专用指令将导致输出不符合要求
- **实施**：完成主任务；顺带修复明显缺陷；顺带简化重复代码；保留原注释与结构
- **验证**：代码变更必须编译通过；找到相关测试则运行；仅文档变更可跳过
- **AskQuestions 多选确认**：使用 `vscode_askQuestions` 工具，多选询问用户是否满意；若需调整则修改后重新编译，循环至满意；确认满意后才进入下一项开发

### 主动优化原则

用户要求**分析/优化代码**时：

| 行动 | 说明 |
|------|------|
| **架构梳理** | 重构不清晰的结构，让代码更易懂 |
| **缺陷修复** | 资源泄漏、空引用、并发问题、逻辑错误 → 直接修复 |
| **代码简化** | 提取重复代码、合并冗余判断、应用现代语法 |
| **性能优化** | 缓存重复计算、池化高频对象、避免无用分配 |
| **注释完善** | 补充缺失的 XML 注释和关键逻辑说明 |

---

## 8. 测试

- 框架 xUnit；类名 `{ClassName}Tests`；方法加 `[DisplayName("中文描述意图")]`
- 网络端口用 `0`/随机，IO 用临时目录
- 先搜索 `{ClassName}` 引用定位测试文件，再找 `{ClassName}Tests.cs`；**未找到需说明**，不自动创建测试项目

---

## 9. 文档与发布

### Markdown 文档

**UTF-8 无 BOM**；存放 `Doc/` 目录；文件名优先中文，内容优先简体中文，避免乱码。**已有文件必须先读取再增量修改，禁止覆盖。**

> 代码注释同样要求 UTF-8 无 BOM，优先简体中文。生成或编辑任何文件时须确保编码正确，防止中文乱码。

### NuGet 版本

| 类型 | 格式 | 示例 |
|------|------|------|
| 正式版 | `{主}.{子}.{年}.{月日}` | `11.9.2025.0701` |
| 测试版 | `{主}.{子}.{年}.{月日}-beta{时分}` | `11.9.2025.0701-beta0906` |

---

## 10. 重要禁止项

以下是 AI 容易犯但在本项目影响严重的错误：

- 将 `String`/`Int32` 改为 `string`/`int`（本项目反 C# 惯例，**必须用正式名**）
- 删除防御性注释（带说明的注释代码）
- 删除 for/foreach/while 循环体的花括号（**循环体必须有花括号，即使只有一行**）
- 将 `<summary>` 拆成多行
- 擅自删除 `public`/`protected` 成员
- 擅自新增外部 NuGet 依赖（需说明理由）
- 仅删除空白行/注释制造"格式优化"提交
- 虚构不存在的 API/文件/类型
- 伪造测试结果/性能数据
- 在热点路径添加未缓存反射/复杂 Linq
- 输出敏感凭据/内部地址
- 发现问题却视而不见
- 用户要求优化时仅做注释/测试等表面工作
- **跳过第 1 节触发检查**（命中关键词却未加载专用指令文件，是最严重的遗漏错误）

---

## 11. 变更说明模板

```markdown
## 概述
做了什么 / 为什么

## 影响
- 公共 API：是/否
- 性能影响：无/有（说明）

## 兼容性
降级策略 / 条件编译点

## 风险与后续
潜在回归 / 是否补测试
```

---

## 12. Skills 技能文件

`.github/skills/` 目录下的技能文件提供特定领域的详细使用指南和代码示例，用户可在 Copilot Chat 中通过 `#` 引用。

| 技能文件 | 覆盖领域 |
|---------|---------|
| `caching.skill.md` | ICache/MemoryCache/Redis 统一缓存接口 |
| `logging-tracing.skill.md` | ILog/XTrace 日志与 ITracer/DefaultTracer 链路追踪 |
| `networking.skill.md` | NetServer/NetSession TCP/UDP/WebSocket 网络编程 |
| `serialization.skill.md` | JSON/Binary/Span/CSV 序列化 |
| `configuration.skill.md` | Config&lt;T&gt;/IConfigProvider/HttpConfigProvider 配置管理 |
| `http-client.skill.md` | ApiHttpClient 多节点 HTTP 客户端与负载均衡 |
| `dependency-injection.skill.md` | ObjectContainer/Host/Plugin/Actor 依赖注入与宿主 |
| `timer-scheduling.skill.md` | TimerX/Cron 高级定时调度 |
| `security.skill.md` | Hash/AES/SM4/RSA/JWT/TokenProvider 安全与加密 |
| `type-conversion.skill.md` | ToInt/ToBoolean/StringHelper/Pool.StringBuilder 类型转换与工具 |

---

## 13. Agents 智能代理

`.github/agents/` 目录下定义了专用 AI 代理角色，用户可在 Copilot Chat 中通过 `@` 调用。

| 代理文件 | 用途 |
|---------|------|
| `newlife-expert.agent.md` | NewLife 组件专家：功能查询、组件推荐、编码指导 |
| `code-review.agent.md` | 代码审查：按 NewLife 规范 8 维度检查代码 |
| `project-init.agent.md` | 项目初始化：按模板创建新 NewLife 项目结构 |

---

（完）


================================================
FILE: .github/instructions/benchmark.instructions.md
================================================
---
applyTo: "**/Benchmark/**"
---

# 性能测试指令

适用于性能测试、压力测试、基准测试、BenchmarkDotNet 相关任务。

---

## 1. 项目结构

- 基准测试统一放在 `Benchmark/` 项目，按主题分子目录（如 `PacketBenchmarks/`、`CacheBenchmarks/`）
- 入口 `Program.cs` 使用 `BenchmarkSwitcher` 模式，**不要修改**
- TFM 使用最新稳定版，`<LangVersion>latest</LangVersion>`

## 2. 代码规范

遵循主指令全部编码规范（类型名用 `String`/`Int32` 等、file-scoped namespace），另有以下补充：

- **命名空间**：`Benchmark.{主题}Benchmarks`
- **类名**：`{被测类型}Benchmark` 或 `{被测主题}Benchmark`
- **必须标注** `[MemoryDiagnoser]` 和 `[SimpleJob]`（需调整迭代次数时用 `[SimpleJob(iterationCount: N)]`）
- **方法描述**：`[Benchmark(Description = "中文描述")]`，方便报告阅读
- **参数化**：用 `[Params]` 或 `[ParamsSource]` 控制数据规模
- **初始化 / 清理**：分别放 `[GlobalSetup]` 和 `[GlobalCleanup]`
- **分组**：同类测试用 `#region` 分组
- **多线程并发**：动态线程数包含 CPU 核心数，推荐模板：

```csharp
public static IEnumerable<Int32> ThreadCounts
{
    get
    {
        var cores = Environment.ProcessorCount;
        var set = new SortedSet<Int32> { 1, 4, 8, 32 };
        set.Add(cores);
        return set;
    }
}

[ParamsSource(nameof(ThreadCounts))]
public Int32 ThreadCount { get; set; }
```

## 3. 运行要求

- 必须以 **Release 模式**运行，获取有代表性的峰值数据
- 运行全部：`dotnet run -c Release`
- 运行指定类：`dotnet run -c Release -- --filter *ClassName*`
- ❌ 禁止在 Debug 模式下采集数据写入报告

## 4. 测试维度

- **并发维度**：单线程 + 多线程（多线程含与当前 CPU 核心数相同的并发数）
- **操作维度**：单一操作 + 批量操作

## 5. 常见错误

- ❌ 在 `[Benchmark]` 方法内做初始化（应放 `[GlobalSetup]`）
- ❌ 忽略返回值导致 JIT 死码消除（确保返回或赋值给字段）
- ❌ 手动 `Stopwatch` 计时（BDN 自动处理）
- ❌ `using` 的 `Dispose` 开销混入测量（仅在测试 Dispose 本身时才包含）

## 6. 报告存放

`Doc/Benchmark/{测试主题}性能测试.md`（UTF-8 无 BOM）

## 7. 报告结构（顺序固定）

1. **性能概览**（放最前：一句话点明被测功能用途 + 简单语言总结核心发现）
2. 测试环境 → 测试方法 → 测试结果（BDN 原始表格，保留 Mean/Error/StdDev/Allocated）
3. 核心指标（换算 msg/s、QPS 等业务指标）
4. **对比分析**
   - 纵向：同场景不同并发趋势，找出最优并发点
   - 横向：不同方案同并发差异百分比
5. 性能瓶颈定位（按重要程度排序）→ 优化建议（含预期收益与内存节省预估）

## 8. 性能瓶颈定位规范

性能瓶颈定位章节是报告的核心价值输出，必须遵循以下规范：

### 8.1 瓶颈点结构（每个瓶颈必须包含）

每个瓶颈点必须包含以下要素，缺一不可：

| 要素 | 说明 | 示例 |
|------|------|------|
| **优先级标签** | P0/P1/P2/P3，按影响程度降序 | P0 |
| **瓶颈名称** | 一句话准确描述瓶颈 | VisitTime 写入触发 MESI 缓存行争用 |
| **优化收益占比** | 该瓶颈在总体可优化空间中的占比 | ~35% |
| **现象与数据** | 用 BDN 实测数据量化问题严重程度 | 4T→8T 扩展仅 1.3x，低于预期 2.0x |
| **根因分析** | 从代码执行路径分析到底层硬件行为 | Get 每次写 VisitTime → 缓存行 Modified → 多核 MESI 失效 |
| **开销占比估算** | 在单次操作总耗时中的占比 | 占 Get 总耗时 30%~40% |
| **内存影响** | 每次操作的额外内存分配或 GC 压力 | 48 B/次装箱分配，32 线程累计 3 MB |
| **优化方向** | 具体可落地的优化方案 | 时间窗口内跳过更新（如 1s 内不重复写） |
| **预期收益** | 速度提升倍数 + 内存节省比例 | 多线程吞吐 +20-30%，消除缓存行争用 |

### 8.2 瓶颈分级标准

| 级别 | 定义 | 优化收益占比 | 行动 |
|------|------|------------|------|
| **P0** | 影响核心吞吐或造成 >30% 性能损失 | ≥25% | 必须优化 |
| **P1** | 影响多线程扩展性或造成显著内存压力 | 15%~25% | 建议优化 |
| **P2** | 特定场景下的次要瓶颈 | 5%~15% | 可选优化 |
| **P3** | 微小开销，仅在极端场景有影响 | <5% | 记录备查 |

### 8.3 瓶颈定位表格模板

性能瓶颈定位章节使用以下统一表格格式：

```markdown
### 核心瓶颈点总览

| 优先级 | 瓶颈 | 优化收益占比 | 当前开销 | 优化后预估 | 内存节省 |
|--------|------|------------|---------|-----------|---------|
| P0 | {瓶颈名称} | ~{X}% | {耗时/分配} | {目标值} | {节省比例} |
| P1 | {瓶颈名称} | ~{X}% | {耗时/分配} | {目标值} | {节省比例} |
| ... | ... | ... | ... | ... | ... |
```

### 8.4 内存优化方向表格模板

紧跟瓶颈总览表之后，补充内存优化方向：

```markdown
### 关键内存优化方向

| 优先级 | 优化方向 | 当前分配 | 优化后预估 | 节省比例 | 实施方案 |
|--------|---------|---------|-----------|---------|---------|
| P0 | {方向} | {X} B/op | {Y} B/op | {Z}% | {方案} |
| ... | ... | ... | ... | ... | ... |
```

### 8.5 开销拆解要求

对每个核心操作，必须给出开销来源拆解表：

```markdown
| 开销来源 | 占比估算 | 耗时估算 | 说明 |
|---------|---------|---------|------|
| {来源1} | ~{X}% | ~{N} ns | {原因} |
| {来源2} | ~{X}% | ~{N} ns | {原因} |
```

### 8.6 撰写原则

- **数据驱动**：所有结论必须有 BDN 实测数据支撑，禁止无数据臆测
- **量化优先**：用"快 X 倍"、"省 Y%"、"降 Z B/op"表达，避免"显著"、"明显"等模糊词
- **根因到底**：从应用层代码 → 运行时机制 → CPU 微架构逐层分析
- **可操作**：每个优化建议必须指明具体修改位置和实施方案，而非泛泛建议
- **排序严格**：P0 在前，P3 在后，同级按收益占比降序


================================================
FILE: .github/instructions/development.instructions.md
================================================
---
applyTo: "Doc/**"
---

# AI 辅助开发流程指令

适用于新建应用系统、新增功能模块、需求整理、架构设计等研发全流程任务。

---

## 1. 流程总览

```
需求整理 → 需求评审与拆分 → 技术方案设计 → 任务分解 → 迭代开发 → 集成验证 → 验收回顾
```

**核心原则**：大需求必须拆小，每个迭代交付可验证的最小功能单元。禁止"一次性全做完"。

---

## 2. 各阶段规范

### 2.1 需求整理

用户提供原始描述（口语化、列表、草稿均可），AI 整理为以下结构（需求 + 功能清单 + 验收 合为一个文件）：

```markdown
# {项目/模块名}需求

## 1. 背景与目标
- 为什么做（痛点/动机）
- 做到什么程度算成功（可衡量目标）

## 2. 用户角色
| 角色 | 说明 | 核心诉求 |
|------|------|---------|

## 3. 功能需求
### 3.1 {功能模块名}
- **描述**：一句话说明
- **用户故事**：作为{角色}，我希望{操作}，以便{价值}
- **验收条件**（AC）：
  - [ ] 条件 1
  - [ ] 条件 2
- **优先级**：Must / Should / Could / Won't

## 4. 非功能需求
- 性能 / 安全 / 兼容性（三项必填）

## 5. 边界与约束
- 不做什么（明确排除项）
- 已知限制 / 技术债务

## 6. 功能清单与迭代计划
（需求评审拆分后填写，见 2.2）

## 7. 验收记录
（开发完成后填写，见 2.7）

## 8. 术语表
| 术语 | 定义 |
|------|------|
```

**规则**：每个功能必须有 AC，无 AC 不可进入开发；优先级用 MoSCoW 四级；非功能需求至少覆盖性能、安全、兼容性。

### 2.2 需求评审与拆分

按**纵向切片**（端到端功能，非技术层）拆分，遵循 INVEST 原则，单个功能单元 ≤ 1-2 天工作量，有依赖须标注。

写入需求文档「6. 功能清单与迭代计划」：

```markdown
## 6. 功能清单与迭代计划

### 迭代 1：{主题}（Must 级别）
| 编号 | 功能点 | 验收条件 | 前置依赖 | 预估工作量 |
|------|--------|---------|---------|----------|
| F001 | xxx | AC1, AC2 | 无 | 0.5d |
| F002 | xxx | AC1 | F001 | 1d |

### 迭代 2：{主题}（Should 级别）
...
```

### 2.3 技术方案设计

```markdown
# {项目/模块名}架构

## 1. 架构概览
## 2. 数据模型
## 3. 接口设计
| 接口 | 方法 | 路径/签名 | 入参 | 出参 | 说明 |
|------|------|----------|------|------|------|
## 4. 技术选型
| 领域 | 选型 | 理由 |
|------|------|------|
## 5. 关键设计决策
| 决策点 | 方案 | 备选方案 | 选择理由 |
|--------|------|---------|---------|
## 6. 任务分解
（见 2.4）
## 7. 风险与缓解
| 风险 | 影响 | 缓解措施 |
|------|------|---------|
```

**规则**：优先使用 NewLife 已有组件（XCode、Remoting、Stardust 等）；数据模型考虑 XCode 实体规范；接口遵循现有 API 风格。

### 2.4 任务分解

单个任务 = 一次 AI 对话可完成的工作量（编码 + 测试 + 自测通过）。写入技术方案「6. 任务分解」：

```markdown
### 任务 T001：{动词 + 目标}
- **对应功能**：F001
- **输入**：前置条件 / 已有代码
- **产出**：新增/修改哪些文件
- **验收**：怎样算完成
```

**批次编排**（用于自治模式，见第 6 节）：按依赖关系编排为批次，每批次 5-8 个任务，同批次内尽量无相互依赖，基础设施任务排在前面，每批次结束设 `[检查点 N]`，标注本批次产出是下批次哪些输入。

### 2.5 迭代开发

流程：`理解任务 → 检索现有实现 → 编码 → 编译通过 → 测试通过 → 提交说明`

- 严格遵守主指令编码规范，每个任务必须编译通过
- 常规模式：遇歧义暂停确认；自治模式：记录跳过继续（见第 6 节）
- 有依赖按顺序执行，不跳跃

### 2.6 集成验证

全部编译通过 → 单元测试通过 → 端到端主流程走通 → 异常场景覆盖 → 性能符合预期

### 2.7 验收与回顾

对照需求文档逐条验收，写入「7. 验收记录」：

```markdown
## 7. 验收记录

### 功能验收
| 编号 | 功能点 | 验收条件 | 状态 | 备注 |
|------|--------|---------|------|------|

### 遗留问题
| 问题 | 影响 | 后续计划 |
|------|------|---------|

### 经验总结
- 做得好的 / 待改进的
```

---

## 3. 文档存放规范

全流程仅产出 **2 个文档**，扁平存放在 `Doc/` 下：

| 文档 | 文件名 | 包含内容 |
|------|--------|--------|
| 需求文档 | `Doc/{项目名}需求.md` | 背景目标 + 功能需求 + 功能清单 + 验收记录 + 术语表 |
| 技术方案 | `Doc/{项目名}架构.md` | 架构 + 数据模型 + 接口 + 技术选型 + 任务分解 + 风险 |

UTF-8 无 BOM；已有文件必须先读取再增量修改，禁止覆盖；各阶段产出追加到对应章节，不新建文件。

---

## 4. AI 协作要点

### 4.1 阶段切换

| 用户说 | 进入阶段 |
|--------|---------|
| "整理需求"/"写需求" | 2.1 需求整理 |
| "拆分"/"拆解"/"排优先级" | 2.2 需求评审与拆分 |
| "技术方案"/"架构设计"/"怎么实现" | 2.3 技术方案设计 |
| "开始开发"/"写代码"/"实现 F001" | 2.5 迭代开发 |
| "全部搞完"/"批量开发"/"自治模式"/"一次性做完"/"继续处理"/"接着做" | 第 6 节自治批处理 |
| "验收"/"检查完成情况" | 2.7 验收与回顾 |
| 一大段描述未指定阶段 | 默认 2.1 需求整理 |

### 4.2 主动引导

每阶段完成后提示下一步：需求整理完 → 拆分？ → 技术方案？ → 任务分解 → 开发？

### 4.3 大需求防护

功能点 > 5 / 实体 > 3 / 跨 2 层以上 / 描述 > 500 字 → 必须先拆分再开发。

---

## 5. 常见反模式（禁止）

- ❌ 跳过需求直接编码
- ❌ 一次性输出所有代码（大需求必须拆迭代或使用自治模式）
- ❌ 需求文档没有验收条件
- ❌ 功能拆分按技术层而非用户价值
- ❌ 任务没有完成标准就开始编码
- ❌ 完成后不做验收对照
- ❌ 自治模式下遇阻塞问题死等用户（应记录跳过，继续后续）
- ❌ 自治模式下做需要人工决策的架构变更（应记录待确认，现有方案兜底）
- ❌ 跨批次不做编译验证

---

## 6. 自治批处理模式

架构师已确认需求和技术方案后，AI 按任务清单自主执行，最小化人工介入。

### 6.1 进入条件（全部满足）

- [ ] 需求文档已完成且架构师已确认
- [ ] 技术方案已完成且架构师已确认
- [ ] 任务已分解并编排为批次
- [ ] 用户明确触发（"全部搞完"/"批量开发"/"自治模式"等）

未满足时提示缺少哪些条件。

### 6.2 计划结构与循环刷新

AI 用 plan 工具创建层次化计划，「前置刷新 + 批次执行」循环：

```
1. [前置] 读取需求文档与技术方案
2. [前置] 读取任务清单与进度状态
3. [前置] 全量编译确认基线
4. [前置] 识别可并行的批次组
5. [批次1] 执行 T001-T005（子步骤展开各任务）
6. [检查点1] 输出批次1报告
7. [刷新] 重读需求文档与技术方案
8. [批次2] 执行 T006-T010
9. [检查点2] 输出批次2报告
...（循环：刷新 → 批次 → 检查点）
N-2. [后置] 全量编译与集成验证
N-1. [后置] 补完被跳过的任务
N.   [后置] 生成验收报告
```

**要点**：
- 主步骤 15-25 个（不超过 30），子步骤展开具体任务仅供参考不单独追踪
- 刷新步骤穿插在每两个批次之间，`get_file` 重读文档对抗上下文漂移
- 用 `update_plan_progress` 跟踪主步骤，不为每个子任务调用
- 无依赖的批次可合并为一个主步骤执行，有依赖的必须顺序执行

### 6.3 执行协议

| 情况 | 处理方式 |
|------|----------|
| 任务明确无歧义 | 直接执行：编码 → 编译 → 测试 |
| 小歧义可合理推断 | 执行并在问题日志记录推断依据 |
| 重大歧义或多种等价方案 | 标记 `⏸️ 待确认`，跳过 |
| 前置任务被跳过 | 标记 `⏸️ 依赖阻塞：T0xx`，跳过 |
| 编译失败短时间无法修复 | 回滚改动，记录并跳过 |
| 涉及公共 API / 架构变更 | 标记 `⏸️ 需架构师决策`，兜底或跳过 |

### 6.4 检查点报告

每批次完毕后输出：

```markdown
## 检查点 N 报告

### 完成情况
| 任务 | 状态 | 说明 |
|------|------|------|
| T001 | ✅ 完成 | |
| T003 | ⏸️ 跳过 | 需确认：xxx |

### 编译状态
- 全量编译：✅ 通过 / ❌ 失败（错误详情）

### 问题日志
| 编号 | 类型 | 描述 | 影响任务 | 建议方案 |
|------|------|------|---------|----------|

### 统计
- 本批次 N 个，完成 X 个，跳过 Y 个
- 累计进度：已完成 X / 总计 Z（XX%）
- 上下文预估：{已处理任务数} / {建议上限}
```

### 6.5 用户回复与继续

架构师回来后：AI 呈现检查点报告 → 架构师批量回复问题（"Q001 OK，Q002 选 A"）→ AI 修正推断 + 执行跳过的任务 + 继续下批次 → 循环至完成。

触发词："继续"/"继续处理"/"回复完了"/"接着做"

### 6.6 质量护栏（自动执行）

编译门禁（失败即修复或回滚）/ 命名与技术方案一致 / 编码规范严格遵守 / 新增代码前搜索现有实现避免重复 / 不擅自引入新 NuGet 包

### 6.7 会话边界处理

每个检查点后、连续完成 15+ 任务后、搜索结果不准确时 → 评估是否需要新会话。

**新会话续接模板**：

```
我们在做 {项目名} 的自治批处理开发。
- 需求文档：Doc/{项目名}需求.md
- 技术方案：Doc/{项目名}架构.md
- 当前进度：批次 N 已完成，从批次 N+1 的 T0xx 开始继续
- 待解决问题：{问题编号}
请读取以上文档，从 T0xx 继续执行，自治模式。
```

上下文即将耗尽时 AI 主动提醒并生成上述模板。新会话前 4 步仍为前置刷新，已完成批次直接标记完成。

### 6.8 批次大小建议

| 复杂度 | 批次大小 |
|--------|---------|
| 简单（CRUD） | 8-10 |
| 中等（业务逻辑） | 5-7 |
| 复杂（算法、并发） | 3-5 |

单会话上限：3-4 个批次（约 15-25 个任务）。

---

（完）


================================================
FILE: .github/instructions/net.instructions.md
================================================
---
applyTo: "**/Net/**"
---

# 网络编程指令

适用于基于 `NewLife.Net` 的网络服务器（`NetServer`）和客户端（`ISocketClient`）开发任务。

---

## 1. 架构概览

NewLife 网络框架分为两层：

| 层级 | 服务端 | 客户端 | 说明 |
|------|--------|--------|------|
| **应用层** | `NetServer` / `NetServer<TSession>` | — | 管理监听、会话生命周期、管道 |
| **传输层** | `TcpServer` / `UdpServer` | `TcpSession` / `UdpServer`（客户端模式） | 底层 Socket 收发 |
| **会话** | `NetSession` / `NetSession<TServer>` | — | 每个连接对应一个会话，业务逻辑入口 |
| **管道** | `IPipeline` + `IPipelineHandler` | 同左 | 编解码、粘包拆包、消息匹配 |

**关键接口**：
- `ISocketClient` — 客户端连接接口（Open/Close/Send/Receive）
- `ISocketRemote` — 远程通信接口（Send/Receive/SendMessageAsync）
- `INetSession` — 网络会话接口（服务端每个连接的业务处理单元）
- `INetHandler` — 网络数据处理器接口（Init/Process）

---

## 2. 服务端开发规范

### 2.1 基本模式

推荐使用泛型 `NetServer<TSession>` + 自定义 `NetSession` 子类：

```csharp
/// <summary>自定义网络服务器</summary>
class MyServer : NetServer<MySession> { }

/// <summary>自定义会话，每个客户端连接对应一个实例</summary>
class MySession : NetSession<MyServer>
{
    /// <summary>客户端连接</summary>
    protected override void OnConnected()
    {
        base.OnConnected();
        WriteLog("客户端已连接 {0}", Remote);
    }

    /// <summary>收到客户端数据</summary>
    protected override void OnReceive(ReceivedEventArgs e)
    {
        base.OnReceive(e);
        // 业务处理
    }

    /// <summary>客户端断开</summary>
    protected override void OnDisconnected(String reason)
    {
        base.OnDisconnected(reason);
    }
}
```

### 2.2 服务器启动配置

```csharp
var server = new MyServer
{
    Port = 8080,                              // 监听端口，0 表示随机
    ProtocolType = NetType.Tcp,               // Tcp/Udp/Unknown（同时监听）
    // AddressFamily = AddressFamily.InterNetwork, // 仅IPv4，默认同时IPv4+IPv6
    ServiceProvider = provider,               // 依赖注入
    Log = XTrace.Log,                         // 应用日志
    SessionLog = XTrace.Log,                  // 会话日志
    Tracer = tracer,                          // APM 追踪
#if DEBUG
    SocketLog = XTrace.Log,                   // Socket 层日志（仅调试）
    LogSend = true,
    LogReceive = true,
#endif
};
server.Start();
```

### 2.3 会话生命周期

```
连接建立 → OnConnected() → OnReceive()... → OnDisconnected(reason) → Dispose()
```

- **OnConnected**：初始化会话状态、发送欢迎消息
- **OnReceive**：核心业务处理入口，`e.Packet` 为原始数据，`e.Message` 为管道解码后的消息
- **OnDisconnected**：清理资源、记录日志，`reason` 包含断开原因
- 会话内可通过 `ServiceProvider` 获取 Scoped 服务

### 2.4 服务端发送数据

| 方法 | 说明 |
|------|------|
| `Send(IPacket)` | 直接发送原始数据，不经过管道 |
| `Send(String)` | 发送字符串，默认 UTF-8 |
| `Send(ReadOnlySpan<Byte>)` | 高性能发送 |
| `SendMessage(Object)` | 通过管道编码后发送，不等待响应 |
| `SendReply(Object, ReceivedEventArgs)` | 发送响应消息，与请求关联（用于 StandardCodec 等协议） |
| `SendMessageAsync(Object)` | 通过管道发送并等待响应 |

### 2.5 群发

```csharp
// 群发数据给所有在线客户端
await server.SendAllAsync(data);

// 带过滤条件群发
await server.SendAllAsync(data, session => session.ID > 100);

// 群发管道消息
server.SendAllMessage(message, session => session["VIP"] is true);
```

群发要求 `UseSession = true`（默认开启）。

### 2.6 事件模式（简单场景）

不需要自定义会话时，可直接使用事件：

```csharp
var server = new NetServer { Port = 8080 };
server.Received += (sender, e) =>
{
    if (sender is INetSession session)
        session.Send(e.Packet);  // Echo
};
server.Start();
```

---

## 3. 客户端开发规范

### 3.1 创建客户端

通过 `NetUri.CreateRemote()` 扩展方法创建：

```csharp
// TCP 客户端
var client = new NetUri("tcp://127.0.0.1:8080").CreateRemote();

// UDP 客户端
var client = new NetUri("udp://127.0.0.1:8080").CreateRemote();

// WebSocket 客户端
var client = new NetUri("ws://127.0.0.1:8080/path").CreateRemote();
```

`CreateRemote` 根据协议自动返回 `TcpSession` / `UdpServer` / `WebSocketClient`。

### 3.2 客户端使用

```csharp
var uri = new NetUri("tcp://127.0.0.1:8080");
var client = uri.CreateRemote();
client.Log = XTrace.Log;
client.Open();

// 发送原始数据（不经过管道）
client.Send("Hello");

// 事件驱动接收
client.Received += (sender, e) =>
{
    // e.Packet 原始数据，e.Message 管道解码后的消息
};

// 或同步/异步接收
using var pk = client.Receive();
using var pk = await client.ReceiveAsync(cancellationToken);

client.Close("完成");  // 或 client.Dispose()
```

### 3.3 请求-响应模式（需要管道编解码器）

```csharp
var client = new NetUri("tcp://127.0.0.1:8080").CreateRemote();
client.Add<StandardCodec>();
client.Open();

var response = await client.SendMessageAsync(payload, cancellationToken);  // 等待响应
client.SendMessage(message);  // 不等待响应
```

### 3.4 SSL/TLS

```csharp
// 服务端 SSL
var server = new NetServer
{
    Port = 443,
    SslProtocol = SslProtocols.Tls12,
    Certificate = new X509Certificate2("server.pfx", "password"),
};

// 客户端 SSL（自动根据端口判断，或手动指定）
var client = new NetUri("tcp://host:443").CreateRemote();
if (client is TcpSession tcp)
{
    tcp.SslProtocol = SslProtocols.Tls12;
    // tcp.Certificate = cert;  // 客户端证书（如果服务端要求）
}
```

---

## 4. 管道与编解码器

### 4.1 管道机制

管道（`IPipeline`）是处理器链，Read/Write 返回值作为下一个处理器的输入，返回 `null` 截断管道：

```
接收：Socket → [Codec1.Read] → [Codec2.Read] → FireRead → OnReceive
发送：SendMessage → [Codec2.Write] → [Codec1.Write] → FireWrite → Socket
```

Open 正序传播，Close 逆序传播。先添加的在底层（靠近 Socket），后添加的在上层（靠近业务）。

### 4.2 内置编解码器

| 编解码器 | 基类 | 说明 | 典型场景 |
|---------|------|------|---------|
| `StandardCodec` | `MessageCodec<IMessage>` | 4字节头部（Flag+Seq+Length），支持请求-响应匹配 | 自定义 RPC 协议 |
| `LengthFieldCodec` | `MessageCodec<IPacket>` | 长度字段头部，可配置偏移和大小 | MQTT、通用二进制协议 |
| `JsonCodec` | `Handler` | JSON 文本编解码，不处理粘包 | 文本协议（通常与 StandardCodec 级联） |
| `SplitDataCodec` | `Handler` | 分隔符拆包（默认 `\r\n`） | 文本行协议 |
| `WebSocketCodec` | `Handler` | WebSocket 帧编解码 | WebSocket 通信 |

### 4.3 添加编解码器

```csharp
// 服务端添加
server.Add<StandardCodec>();

// 客户端添加
client.Add<StandardCodec>();

// 多层管道级联（按添加顺序组成链）
server.Add<StandardCodec>();  // 底层：粘包拆包 + 请求响应匹配
server.Add<JsonCodec>();      // 上层：JSON 编解码
```

### 4.4 StandardCodec 请求-响应

StandardCodec 使用 `DefaultMessage`，包含 Flag（1字节）、Sequence（1字节）、Length（2字节），
支持自动序列号分配和请求-响应匹配。

```csharp
// 服务端 Echo 示例
server.Add<StandardCodec>();
server.Received += (sender, e) =>
{
    if (sender is INetSession session && e.Message is IPacket pk)
        session.SendReply(pk, e);  // 使用 SendReply 关联请求上下文
};

// 客户端请求-响应
client.Add<StandardCodec>();
var response = await client.SendMessageAsync(payload);
```

### 4.5 基类选择

| 基类 | 适用场景 | 典型代表 |
|------|---------|---------|
| `MessageCodec<T>` | 需要粘包拆包和/或请求-响应匹配（内置 `IMatchQueue`、`Encode`/`Decode`） | `StandardCodec`、`LengthFieldCodec` |
| `Handler` | 简单转换、帧协议、文本协议（轻量，仅 `Read`/`Write`/`Open`/`Close`） | `JsonCodec`、`SplitDataCodec`、`WebSocketCodec` |

### 4.6 编解码器设计规范

#### 4.6.1 粘包拆包（PacketCodec 模式）

TCP 是字节流协议，必须处理粘包拆包。统一模式（完整实现见 4.7 模板）：

1. 每个连接独立的 `PacketCodec` 实例，存储在 `ss["Codec"]` 中
2. 通过 `GetLength2` 委托告诉 `PacketCodec` 如何计算完整帧长度
3. `PacketCodec.Parse()` 返回完整帧列表，自动缓存不完整数据

**`GetLength2` 规范**（签名 `Int32 GetLength(ReadOnlySpan<Byte> span)`）：返回帧完整长度（含头部），数据不足时返回 `0`。

```csharp
public static Int32 GetLength(ReadOnlySpan<Byte> span)
{
    if (span.Length < 4) return 0;
    var reader = new SpanReader(span) { IsLittleEndian = true };
    reader.Advance(2);
    return 4 + reader.ReadUInt16();  // 头部4字节 + 负载长度
}
```

#### 4.6.2 编码与内存管理

- **`ExpandHeader(size)`**：编码时优先复用负载缓冲区前置空间写入头部，零拷贝；空间不足时创建 `OwnerPacket`，原包作为 `Next` 链节点
- **`SpanWriter`**：配合 `ExpandHeader` 写入头部字段，注意 `IsLittleEndian` 大小端
- **兜底释放**：`MessageCodec<T>.Write` 基类自动 `TryDispose`；`Handler` 子类需在 `Write` 的 `finally` 中手动调用
- **对象池**：`DefaultMessage.Rent()` / `DefaultMessage.Return()` 减少 GC 压力

#### 4.6.3 请求-响应匹配

`MessageCodec<T>` 内置 `IMatchQueue`，流程：`Write` → `AddToQueue` 入队 → `Decode` 解码 → `Queue.Match` 按 `IsMatch` 匹配 → 唤醒 `SendMessageAsync` 的 `Task`。

- 重载 `AddToQueue`：控制哪些消息入队（通常只有请求消息）
- 重载 `IsMatch`：根据序列号等字段匹配请求和响应（见 4.7 模板）
- `QueueSize`：匹配队列大小，默认 256
- `Timeout`：等待响应超时，默认 30_000ms
- `UserPacket`：为 `true` 时向上层传递 `Payload` 而非整个 `IMessage`，用于编码器级联

#### 4.6.4 Close 清理

**必须**在 `Close` 中执行 `ss["Codec"] = null` 清理 `PacketCodec`，否则 `MemoryStream` 缓存泄漏（见 4.7 模板）。

#### 4.6.5 上下文扩展（IExtend）

管道处理器通过 `IExtend` 在会话/上下文上传递元数据：

| 键 | 用途 | 示例 |
|---|------|------|
| `"Codec"` | 每连接的 `PacketCodec` 实例 | 编解码器的 `Decode`/`Close` 中读写 |
| `"Flag"` | 数据类型标记 `DataKinds` | `JsonCodec.Write` 设置 → `StandardCodec.Write` 消费 |
| `"_raw_message"` | 原始请求消息 | `MessageCodec.Read` 设置 → `Write` 中创建响应时消费 |
| `"TaskSource"` | `TaskCompletionSource` | 框架内部，`AddToQueue` 消费 |

#### 4.6.6 多层管道级联

- 底层编解码器处理粘包拆包和请求-响应匹配，上层处理数据格式转换
- `UserPacket = true` 让底层向上层传递 `Payload` 而非整个 `IMessage`
- 上层通过 `ext["Flag"]` 向底层传递数据类型标记

### 4.7 自定义编解码器模板

#### 方式一：继承 MessageCodec<T>（需要粘包/请求响应匹配）

```csharp
/// <summary>自定义协议编解码器</summary>
public class MyCodec : MessageCodec<MyMessage>
{
    /// <summary>编码消息为数据包</summary>
    protected override Object? Encode(IHandlerContext context, MyMessage msg)
    {
        return msg.ToPacket();
    }

    /// <summary>解码数据包为消息</summary>
    protected override IEnumerable<MyMessage>? Decode(IHandlerContext context, IPacket pk)
    {
        if (context.Owner is not IExtend ss) yield break;

        if (ss["Codec"] is not PacketCodec pc)
        {
            ss["Codec"] = pc = new PacketCodec
            {
                GetLength2 = MyMessage.GetLength,
                MaxCache = MaxCache,
                Tracer = (context.Owner as ISocket)?.Tracer
            };
        }

        foreach (var item in pc.Parse(pk))
        {
            var msg = new MyMessage();
            if (msg.Read(item)) yield return msg;
        }
    }

    /// <summary>是否匹配响应</summary>
    protected override Boolean IsMatch(Object? request, Object? response) =>
        request is MyMessage req && response is MyMessage res
        && req.Sequence == res.Sequence;

    /// <summary>连接关闭时清理</summary>
    public override Boolean Close(IHandlerContext context, String reason)
    {
        if (context.Owner is IExtend ss) ss["Codec"] = null;

        return base.Close(context, reason);
    }
}
```

#### 方式二：继承 Handler（简单转换/帧协议）

```csharp
/// <summary>自定义帧编解码器</summary>
public class MyFrameCodec : Handler
{
    /// <summary>读取数据（接收时）</summary>
    public override Object? Read(IHandlerContext context, Object message)
    {
        if (message is IPacket pk)
        {
            // 解码：二进制 → 业务对象
            var frame = MyFrame.Parse(pk);
            message = frame;
        }

        return base.Read(context, message);
    }

    /// <summary>写入数据（发送时）</summary>
    public override Object? Write(IHandlerContext context, Object message)
    {
        IPacket? owner = null;
        if (message is MyFrame frame)
        {
            // 编码：业务对象 → 二进制
            message = owner = frame.ToPacket();
        }

        try
        {
            return base.Write(context, message);
        }
        finally
        {
            owner.TryDispose();  // 兜底释放
        }
    }

    /// <summary>连接关闭时清理缓存</summary>
    public override Boolean Close(IHandlerContext context, String reason)
    {
        if (context.Owner is IExtend ss) ss["Codec"] = null;

        return base.Close(context, reason);
    }
}
```

---

## 5. 常见模式与最佳实践

### 5.1 端口选择

- 测试代码使用端口 `0`（系统自动分配随机端口），避免端口冲突
- 正式服务指定固定端口
- 启动后可通过 `server.Port` 获取实际监听端口

### 5.2 协议选择

| 场景 | 推荐 |
|------|------|
| 可靠传输、长连接 | `NetType.Tcp` |
| 低延迟、广播、允许丢包 | `NetType.Udp` |
| 同时支持（默认） | `NetType.Unknown` |
| Web 浏览器通信 | `NetType.WebSocket` |

### 5.3 会话管理

- `UseSession = true`（默认）：维护会话集合，支持群发、按 ID 查找
- `UseSession = false`：不维护会话集合，减少内存开销，适合海量短连接
- `SessionTimeout`：设置会话超时时间（秒），超时无数据自动断开
- 会话中通过 `Items` 字典存储自定义数据

### 5.4 日志分层

| 属性 | 用途 | 建议 |
|------|------|------|
| `Log` | 服务器应用层日志 | 始终设置 |
| `SessionLog` | 会话级别日志 | 调试时设置 |
| `SocketLog` | 底层 Socket 日志 | 仅 DEBUG 时设置 |
| `LogSend` / `LogReceive` | 收发数据内容日志 | 仅 DEBUG 时开启 |
| `Tracer` | 应用层 APM | 生产环境追踪 |
| `SocketTracer` | Socket 层 APM | 排查底层问题 |

### 5.5 资源释放

- 服务端：调用 `server.Stop(reason)` 或 `server.Dispose()`
- 客户端：调用 `client.Close(reason)` 或 `client.Dispose()`
- 会话自动随连接断开释放，无需手动管理
- `ISocketClient` 实现 `IDisposable`，推荐 `using` 模式

### 5.6 INetHandler 业务处理器

通过重载 `NetServer.CreateHandler` 注入自定义业务处理器：

```csharp
class MyServer : NetServer<MySession>
{
    /// <summary>为会话创建网络数据处理器</summary>
    public override INetHandler? CreateHandler(INetSession session) => new MyHandler();
}
```

处理器在会话 `Start` 时初始化，`OnReceive` 前调用 `Process`，适合前置协议解析。

---

## 6. 常见错误

- ❌ 在 `OnReceive` 中执行长时间阻塞操作（会影响其他连接的数据接收）
- ❌ 不加管道编解码器直接调用 `SendMessageAsync`（无法匹配响应）
- ❌ 混淆 `Send` 与 `SendMessage`：前者直接发原始数据，后者经过管道编码
- ❌ 混淆 `SendMessage` 与 `SendReply`：响应消息必须用 `SendReply` 关联请求上下文
- ❌ 忘记调用 `base.OnConnected()` / `base.OnDisconnected(reason)` / `base.OnReceive(e)`
- ❌ 在会话中使用 `Task.Result` 或 `Task.Wait()`（导致死锁和线程池饥饿）
- ❌ 使用固定端口编写测试（端口冲突），应使用 `Port = 0`
- ❌ 服务端 SSL 未指定证书

---

## 7. 完整示例

### 7.1 带 StandardCodec 的 Echo 服务

```csharp
// 服务端
var server = new NetServer
{
    Port = 8080,
    ProtocolType = NetType.Tcp,
    Log = XTrace.Log,
};
server.Add<StandardCodec>();
server.Received += (sender, e) =>
{
    if (sender is INetSession session && e.Message is IPacket pk)
        session.SendReply(pk, e);
};
server.Start();

// 客户端
var client = new NetUri($"tcp://127.0.0.1:{server.Port}").CreateRemote();
client.Add<StandardCodec>();
client.Open();

var response = await client.SendMessageAsync(new ArrayPacket("Hello".GetBytes()));
```

### 7.2 自定义会话服务器

```csharp
class ChatServer : NetServer<ChatSession> { }

class ChatSession : NetSession<ChatServer>
{
    protected override void OnConnected()
    {
        base.OnConnected();
        Send($"欢迎 [{Remote}] 进入聊天室！\r\n");
    }

    protected override void OnReceive(ReceivedEventArgs e)
    {
        base.OnReceive(e);
        var msg = e.Packet?.ToStr();
        if (msg.IsNullOrEmpty()) return;

        // 广播给所有在线用户
        var host = (this as INetSession).Host;
        host.SendAllMessage($"[{ID}] {msg}");
    }

    protected override void OnDisconnected(String reason)
    {
        base.OnDisconnected(reason);
        WriteLog("用户离开：{0}", reason);
    }
}
```

---

（完）


================================================
FILE: .github/workflows/publish-beta.yml
================================================
name: publish-beta

on:
  push:
    branches: [ master,dev ]
    paths:
        - 'NewLife.RocketMQ/**'
  workflow_dispatch:

jobs:
  build-publish:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - name: Setup dotNET
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: |
          6.x
          7.x
          8.x
          9.x
          10.x
    - name: Build
      run: |
        dotnet pack --version-suffix $(date "+%Y.%m%d-beta%H%M") -c Release -o out NewLife.RocketMQ/NewLife.RocketMQ.csproj
    - name: Publish
      run: |
        # dotnet nuget push ./out/*.nupkg --skip-duplicate --source https://nuget.pkg.github.com/NewLifeX/index.json --api-key ${{ github.token }}
        dotnet nuget push ./out/*.nupkg --skip-duplicate --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.nugetKey }}


================================================
FILE: .github/workflows/publish.yml
================================================
name: publish

on:
  push:
    tags: [ v* ]
  workflow_dispatch:

jobs:
  build-publish:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - name: Setup dotNET
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: |
          6.x
          7.x
          8.x
          9.x
          10.x
    - name: Build
      run: |
        dotnet pack -c Release -o out NewLife.RocketMQ/NewLife.RocketMQ.csproj
    - name: Publish
      run: |
        # dotnet nuget push ./out/*.nupkg --skip-duplicate --source https://nuget.pkg.github.com/NewLifeX/index.json --api-key ${{ github.token }}
        dotnet nuget push ./out/*.nupkg --skip-duplicate --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.nugetKey }}


================================================
FILE: .github/workflows/test.yml
================================================
name: test

on:
  push:
    branches: [ '*' ]
  pull_request:
    branches: [ '*' ]

jobs:
  build-test:

    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
    - name: Setup dotNET
      uses: actions/setup-dotnet@v4
      with:
        dotnet-version: |
          6.x
          7.x
          8.x
          9.x
          10.x
    - name: Build
      run: |
        dotnet build -c Release


================================================
FILE: .gitignore
================================================
## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.

# User-specific files
*.suo
*.user
*.userosscache
*.sln.docstates

# User-specific files (MonoDevelop/Xamarin Studio)
*.userprefs

# Build results
[Dd]ebug/
[Dd]ebugPublic/
[Rr]elease/
[Rr]eleases/
x64/
x86/
bld/
[Bb]in/
[Oo]bj/
[Ll]og/

# Visual Studio 2015 cache/options directory
.vs/
# Uncomment if you have tasks that create the project's static files in wwwroot
#wwwroot/

# MSTest test Results
[Tt]est[Rr]esult*/
[Bb]uild[Ll]og.*

# NUNIT
*.VisualState.xml
TestResult.xml

# Build Results of an ATL Project
[Dd]ebugPS/
[Rr]eleasePS/
dlldata.c

# DNX
project.lock.json
project.fragment.lock.json
artifacts/

*_i.c
*_p.c
*_i.h
*.ilk
*.meta
*.obj
*.pch
*.pdb
*.pgc
*.pgd
*.rsp
*.sbr
*.tlb
*.tli
*.tlh
*.tmp
*.tmp_proj
*.log
*.vspscc
*.vssscc
.builds
*.pidb
*.svclog
*.scc

# Chutzpah Test files
_Chutzpah*

# Visual C++ cache files
ipch/
*.aps
*.ncb
*.opendb
*.opensdf
*.sdf
*.cachefile
*.VC.db
*.VC.VC.opendb

# Visual Studio profiler
*.psess
*.vsp
*.vspx
*.sap

# TFS 2012 Local Workspace
$tf/

# Guidance Automation Toolkit
*.gpState

# ReSharper is a .NET coding add-in
_ReSharper*/
*.[Rr]e[Ss]harper
*.DotSettings.user

# JustCode is a .NET coding add-in
.JustCode

# TeamCity is a build add-in
_TeamCity*

# DotCover is a Code Coverage Tool
*.dotCover

# NCrunch
_NCrunch_*
.*crunch*.local.xml
nCrunchTemp_*

# MightyMoose
*.mm.*
AutoTest.Net/

# Web workbench (sass)
.sass-cache/

# Installshield output folder
[Ee]xpress/

# DocProject is a documentation generator add-in
DocProject/buildhelp/
DocProject/Help/*.HxT
DocProject/Help/*.HxC
DocProject/Help/*.hhc
DocProject/Help/*.hhk
DocProject/Help/*.hhp
DocProject/Help/Html2
DocProject/Help/html

# Click-Once directory
publish/

# Publish Web Output
*.[Pp]ublish.xml
*.azurePubxml
# TODO: Comment the next line if you want to checkin your web deploy settings
# but database connection strings (with potential passwords) will be unencrypted
#*.pubxml
*.publishproj

# Microsoft Azure Web App publish settings. Comment the next line if you want to
# checkin your Azure Web App publish settings, but sensitive information contained
# in these scripts will be unencrypted
PublishScripts/

# NuGet Packages
*.nupkg
# The packages folder can be ignored because of Package Restore
**/packages/*
# except build/, which is used as an MSBuild target.
!**/packages/build/
# Uncomment if necessary however generally it will be regenerated when needed
#!**/packages/repositories.config
# NuGet v3's project.json files produces more ignoreable files
*.nuget.props
*.nuget.targets

# Microsoft Azure Build Output
csx/
*.build.csdef

# Microsoft Azure Emulator
ecf/
rcf/

# Windows Store app package directories and files
AppPackages/
BundleArtifacts/
Package.StoreAssociation.xml
_pkginfo.txt

# Visual Studio cache files
# files ending in .cache can be ignored
*.[Cc]ache
# but keep track of directories ending in .cache
!*.[Cc]ache/

# Others
ClientBin/
~$*
*~
*.dbmdl
*.dbproj.schemaview
*.jfm
*.pfx
*.publishsettings
node_modules/
orleans.codegen.cs

# Since there are multiple workflows, uncomment next line to ignore bower_components
# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
#bower_components/

# RIA/Silverlight projects
Generated_Code/

# Backup & report files from converting an old project file
# to a newer Visual Studio version. Backup files are not needed,
# because we have git ;-)
_UpgradeReport_Files/
Backup*/
UpgradeLog*.XML
UpgradeLog*.htm

# SQL Server files
*.mdf
*.ldf

# Business Intelligence projects
*.rdl.data
*.bim.layout
*.bim_*.settings

# Microsoft Fakes
FakesAssemblies/

# GhostDoc plugin setting file
*.GhostDoc.xml

# Node.js Tools for Visual Studio
.ntvs_analysis.dat

# Visual Studio 6 build log
*.plg

# Visual Studio 6 workspace options file
*.opt

# Visual Studio LightSwitch build output
**/*.HTMLClient/GeneratedArtifacts
**/*.DesktopClient/GeneratedArtifacts
**/*.DesktopClient/ModelManifest.xml
**/*.Server/GeneratedArtifacts
**/*.Server/ModelManifest.xml
_Pvt_Extensions

# Paket dependency manager
.paket/paket.exe
paket-files/

# FAKE - F# Make
.fake/

# JetBrains Rider
.idea/
*.sln.iml

# CodeRush
.cr/

# Python Tools for Visual Studio (PTVS)
__pycache__/
*.pyc
/BinTest
/BinTest - 副本/Config
/生产
/BinUnitTest


================================================
FILE: ChangeLog.md
================================================
# 更新日志

## v3.0.2026.0501 (2026-05-01)

### 问题修复
- **[fix]** 修复 Pop/Ack/ChangeInvisibleTime 操作缺少 `queueId` 参数导致服务端处理异常的问题
- **便利方法**：`MessageExt` 新增多个便利访问方法，简化消息属性读取

### 依赖更新
- 升级 NewLife.Core 依赖包到最新版本（2026-04-xx）

---

## v3.0.2026.0305 (2026-03-05)

### 云适配重构（重大版本）
- **架构重构**：全面升级为 v3.0 云适配架构，新增 `ICloudProvider` 接口统一阿里云、华为云、腾讯云适配
- **事务消息**：新增 RocketMQ 事务消息发布与回查接口，支持分布式事务场景
- **请求-应答模式**：新增 Request-Reply 同步调用模式，支持消息级 RPC

### gRPC 协议支持
- **gRPC 5.x Proxy**：新增 gRPC 协议支持，零依赖不引入第三方 Protobuf/gRPC 库
- **SpanReader/SpanWriter 重构**：将 gRPC 协议编解码器重构为基于 `SpanReader`/`SpanWriter` 的零分配实现，提升性能
- **gRPC Telemetry**：新增 gRPC Telemetry 链路追踪支持

### 新增功能
- **VIP 通道**：支持 VIP Channel 高优先级消息通道
- **批量确认**：支持批量 Ack 操作，减少网络往返
- **5.x MsgId**：支持 RocketMQ 5.x 消息 ID 格式生成与解析
- **客户端拉取超时**：新增 `Consumer.PullTimeout` 客户端侧应用层超时保护，防止 4.9.8 无响应导致消费线程永久阻塞

### 测试覆盖
- 新增 152 个单元测试，覆盖协议层、模型层、工具类等核心组件
- 完善架构文档与需求文档

---

## v2.7.2026.0301 (2026-03-01)

### 问题修复
- 新增`Consumer.PullTimeout`属性，默认值0表示自动取`SuspendTimeout+10_000ms`，作为客户端拉取消息的应用层超时保护，防止RocketMQ 4.9.8在SuspendTimeout后无响应导致消费线程永久阻塞

## v2.7.2026.0201 (2026-02-01)

### 依赖更新
- 升级 NewLife.Core 依赖包到最新版本（2026-01-24）
- 升级 NewLife.Core 依赖包（2026-01-14）
- 升级 NewLife.Core 依赖包（2026-01-12）

## v2.7.2026.0102 (2026-01-03)

初始发布版本


================================================
FILE: DLL/NewLife.Core.xml
================================================
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>NewLife.Core</name>
    </assembly>
    <members>
        <member name="T:NewLife.Agent.AgentServiceBase`1">
            <typeparam name="TService">服务类型</typeparam>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase`1.ServiceMain">
            <summary>服务主函数</summary>
        </member>
        <member name="T:NewLife.Agent.AgentServiceBase">
            <summary>服务程序基类</summary>
        </member>
        <member name="P:NewLife.Agent.AgentServiceBase.DisplayName">
            <summary>显示名</summary>
        </member>
        <member name="P:NewLife.Agent.AgentServiceBase.Description">
            <summary>描述</summary>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.#ctor">
            <summary>初始化</summary>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.Main">
            <summary>服务主函数</summary>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.ShowStatus">
            <summary>显示状态</summary>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.ShowMenu">
            <summary>显示菜单</summary>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.AddMenu(System.Char,System.String,System.Action)">
            <summary>添加菜单</summary>
            <param name="key"></param>
            <param name="name"></param>
            <param name="callbak"></param>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.StartWork(System.String)">
            <summary>开始工作</summary>
            <param name="reason"></param>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.StopWork(System.String)">
            <summary>停止服务</summary>
            <param name="reason"></param>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.DoCheck(System.Object)">
            <summary>服务管理线程封装</summary>
            <param name="data"></param>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.CheckMemory">
            <summary>检查内存是否超标</summary>
            <returns>是否超标重启</returns>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.CheckThread">
            <summary>检查服务进程的总线程数是否超标</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.CheckHandle">
            <summary>检查服务进程的句柄数是否超标</summary>
            <returns></returns>
        </member>
        <member name="F:NewLife.Agent.AgentServiceBase.Start">
            <summary>服务开始时间</summary>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.CheckAutoRestart">
            <summary>检查自动重启</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.Restart(System.String)">
            <summary>重启服务</summary>
            <param name="reason"></param>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.OnStart(System.String[])">
            <summary>服务启动事件</summary>
            <param name="args"></param>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.OnStop">
            <summary>服务停止事件</summary>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.OnShutdown">
            <summary>在系统关闭时执行。 指定在系统关闭之前应该发生什么。</summary>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.OnPowerEvent(System.ServiceProcess.PowerBroadcastStatus)">
            <summary>在计算机的电源状态已发生更改时执行。 这适用于便携式计算机，当他们进入挂起模式，这不是系统关闭相同。</summary>
            <param name="powerStatus"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.OnSessionChange(System.ServiceProcess.SessionChangeDescription)">
            <summary>在终端服务器会话中接收的更改事件时执行</summary>
            <param name="changeDescription"></param>
        </member>
        <member name="P:NewLife.Agent.AgentServiceBase.WatchDogs">
            <summary>看门狗要保护的服务</summary>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.CheckWatchDog">
            <summary>检查看门狗。</summary>
            <remarks>
            XAgent看门狗功能由管理线程完成，每分钟一次。
            检查指定的任务是否已经停止，如果已经停止，则启动它。
            </remarks>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.Install(System.Boolean)">
            <summary>安装、卸载 服务</summary>
            <param name="isinstall">是否安装</param>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.GetBinPath(System.String)">
            <summary>获取安装服务的命令参数</summary>
            <param name="exe"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Agent.AgentServiceBase.Log">
            <summary>日志</summary>
        </member>
        <member name="M:NewLife.Agent.AgentServiceBase.WriteLog(System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="T:NewLife.Agent.ServiceHelper">
            <summary>服务助手</summary>
        </member>
        <member name="P:NewLife.Agent.ServiceHelper.ExeName">
            <summary>Exe程序名</summary>
        </member>
        <member name="M:NewLife.Agent.ServiceHelper.ControlService(NewLife.Agent.AgentServiceBase,System.Boolean)">
            <summary>启动、停止 服务</summary>
            <param name="service">服务对象</param>
            <param name="isstart"></param>
        </member>
        <member name="M:NewLife.Agent.ServiceHelper.RunCmd(System.String,System.Boolean,System.Boolean)">
            <summary>执行一个命令</summary>
            <param name="cmd"></param>
            <param name="showWindow"></param>
            <param name="waitForExit"></param>
        </member>
        <member name="M:NewLife.Agent.ServiceHelper.RunSC(System.String)">
            <summary>执行SC命令</summary>
            <param name="cmd"></param>
        </member>
        <member name="M:NewLife.Agent.ServiceHelper.IsInstalled(System.String)">
            <summary>是否已安装</summary>
        </member>
        <member name="M:NewLife.Agent.ServiceHelper.IsRunning(System.String)">
            <summary>是否已启动</summary>
        </member>
        <member name="M:NewLife.Agent.ServiceHelper.IsServiceInstalled(System.String)">
            <summary>是否已安装</summary>
        </member>
        <member name="M:NewLife.Agent.ServiceHelper.IsServiceRunning(System.String)">
            <summary>是否已启动</summary>
        </member>
        <member name="M:NewLife.Agent.ServiceHelper.WriteLine(System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="T:NewLife.Agent.Setting">
            <summary>服务设置</summary>
        </member>
        <member name="P:NewLife.Agent.Setting.ServiceName">
            <summary>服务名</summary>
        </member>
        <member name="P:NewLife.Agent.Setting.DisplayName">
            <summary>显示名</summary>
        </member>
        <member name="P:NewLife.Agent.Setting.Description">
            <summary>服务描述</summary>
        </member>
        <member name="P:NewLife.Agent.Setting.MaxMemory">
            <summary>最大占用内存。超过最大占用时，整个服务进程将会重启，以释放资源。默认8096M</summary>
        </member>
        <member name="P:NewLife.Agent.Setting.MaxThread">
            <summary>最大线程数。超过最大占用时，整个服务进程将会重启，以释放资源。默认1000个</summary>
        </member>
        <member name="P:NewLife.Agent.Setting.MaxHandle">
            <summary>最大句柄数。超过最大占用时，整个服务进程将会重启，以释放资源。默认10000</summary>
        </member>
        <member name="P:NewLife.Agent.Setting.AutoRestart">
            <summary>自动重启时间。到达自动重启时间时，整个服务进程将会重启，以释放资源。默认0分，表示无限</summary>
        </member>
        <member name="P:NewLife.Agent.Setting.WatchDog">
            <summary>看门狗，保护其它服务，每分钟检查一次。多个服务名逗号分隔</summary>
        </member>
        <member name="T:NewLife.IP.Ip">
            <summary>IP搜索</summary>
        </member>
        <member name="P:NewLife.IP.Ip.DbFile">
            <summary>数据文件</summary>
        </member>
        <member name="M:NewLife.IP.Ip.GetAddress(System.String)">
            <summary>获取IP地址</summary>
            <param name="ip"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.IP.Ip.GetAddress(System.Net.IPAddress)">
            <summary>获取IP地址</summary>
            <param name="addr"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.IP.Zip.Stream">
            <summary>数据流</summary>
        </member>
        <member name="M:NewLife.IP.Zip.Finalize">
            <summary>析构</summary>
        </member>
        <member name="M:NewLife.IP.Zip.Dispose">
            <summary>销毁</summary>
        </member>
        <member name="T:NewLife.IP.Zip.IndexInfo">
            <summary>索引结构</summary>
        </member>
        <member name="T:NewLife.Caching.Cache">
            <summary>缓存</summary>
        </member>
        <member name="P:NewLife.Caching.Cache.Default">
            <summary>默认缓存</summary>
        </member>
        <member name="P:NewLife.Caching.Cache.Name">
            <summary>名称</summary>
        </member>
        <member name="P:NewLife.Caching.Cache.Expire">
            <summary>默认缓存时间。默认0秒表示不过期</summary>
        </member>
        <member name="P:NewLife.Caching.Cache.Item(System.String)">
            <summary>获取和设置缓存，永不过期</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Caching.Cache.Count">
            <summary>缓存个数</summary>
        </member>
        <member name="P:NewLife.Caching.Cache.Keys">
            <summary>所有键</summary>
        </member>
        <member name="M:NewLife.Caching.Cache.#ctor">
            <summary>构造函数</summary>
        </member>
        <member name="M:NewLife.Caching.Cache.Init(System.String)">
            <summary>初始化配置</summary>
            <param name="config"></param>
        </member>
        <member name="M:NewLife.Caching.Cache.ContainsKey(System.String)">
            <summary>是否包含缓存项</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Set``1(System.String,``0,System.Int32)">
            <summary>设置缓存项</summary>
            <param name="key">键</param>
            <param name="value">值</param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.Cache.Expire"/></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Set``1(System.String,``0,System.TimeSpan)">
            <summary>设置缓存项</summary>
            <param name="key">键</param>
            <param name="value">值</param>
            <param name="expire">过期时间</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Get``1(System.String)">
            <summary>获取缓存项</summary>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Remove(System.String[])">
            <summary>批量移除缓存项</summary>
            <param name="keys">键集合</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Clear">
            <summary>清空所有缓存项</summary>
        </member>
        <member name="M:NewLife.Caching.Cache.SetExpire(System.String,System.TimeSpan)">
            <summary>设置缓存项有效期</summary>
            <param name="key">键</param>
            <param name="expire">过期时间，秒</param>
        </member>
        <member name="M:NewLife.Caching.Cache.GetExpire(System.String)">
            <summary>获取缓存项有效期</summary>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.GetAll``1(System.Collections.Generic.IEnumerable{System.String})">
            <summary>批量获取缓存项</summary>
            <typeparam name="T"></typeparam>
            <param name="keys"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.SetAll``1(System.Collections.Generic.IDictionary{System.String,``0},System.Int32)">
            <summary>批量设置缓存项</summary>
            <typeparam name="T"></typeparam>
            <param name="values"></param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.Cache.Expire"/></param>
        </member>
        <member name="M:NewLife.Caching.Cache.GetList``1(System.String)">
            <summary>获取列表</summary>
            <typeparam name="T">元素类型</typeparam>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.GetDictionary``1(System.String)">
            <summary>获取哈希</summary>
            <typeparam name="T">元素类型</typeparam>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.GetQueue``1(System.String)">
            <summary>获取队列</summary>
            <typeparam name="T">元素类型</typeparam>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.GetSet``1(System.String)">
            <summary>获取Set</summary>
            <typeparam name="T"></typeparam>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Add``1(System.String,``0,System.Int32)">
            <summary>添加，已存在时不更新</summary>
            <typeparam name="T">值类型</typeparam>
            <param name="key">键</param>
            <param name="value">值</param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.Cache.Expire"/></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Replace``1(System.String,``0)">
            <summary>设置新值并获取旧值，原子操作</summary>
            <typeparam name="T">值类型</typeparam>
            <param name="key">键</param>
            <param name="value">值</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Increment(System.String,System.Int64)">
            <summary>累加，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Increment(System.String,System.Double)">
            <summary>累加，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Decrement(System.String,System.Int64)">
            <summary>递减，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Decrement(System.String,System.Double)">
            <summary>递减，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Commit">
            <summary>提交变更。部分提供者需要刷盘</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.AcquireLock(System.String,System.Int32)">
            <summary>申请分布式锁</summary>
            <param name="key"></param>
            <param name="msTimeout"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Cache.Bench(System.Boolean,System.Int32)">
            <summary>多线程性能测试</summary>
            <param name="rand">随机读写</param>
            <param name="batch">批量操作。默认0不分批</param>
            <remarks>
            Memory性能测试[顺序]，逻辑处理器 32 个 2,000MHz Intel(R) Xeon(R) CPU E5-2640 v2 @ 2.00GHz
            
            测试 10,000,000 项，  1 线程
            赋值 10,000,000 项，  1 线程，耗时   3,764ms 速度 2,656,748 ops
            读取 10,000,000 项，  1 线程，耗时   1,296ms 速度 7,716,049 ops
            删除 10,000,000 项，  1 线程，耗时   1,230ms 速度 8,130,081 ops
            
            测试 20,000,000 项，  2 线程
            赋值 20,000,000 项，  2 线程，耗时   3,088ms 速度 6,476,683 ops
            读取 20,000,000 项，  2 线程，耗时   1,051ms 速度 19,029,495 ops
            删除 20,000,000 项，  2 线程，耗时   1,011ms 速度 19,782,393 ops
            
            测试 40,000,000 项，  4 线程
            赋值 40,000,000 项，  4 线程，耗时   3,060ms 速度 13,071,895 ops
            读取 40,000,000 项，  4 线程，耗时   1,023ms 速度 39,100,684 ops
            删除 40,000,000 项，  4 线程，耗时     994ms 速度 40,241,448 ops
            
            测试 80,000,000 项，  8 线程
            赋值 80,000,000 项，  8 线程，耗时   3,124ms 速度 25,608,194 ops
            读取 80,000,000 项，  8 线程，耗时   1,171ms 速度 68,317,677 ops
            删除 80,000,000 项，  8 线程，耗时   1,199ms 速度 66,722,268 ops
            
            测试 320,000,000 项， 32 线程
            赋值 320,000,000 项， 32 线程，耗时  13,857ms 速度 23,093,021 ops
            读取 320,000,000 项， 32 线程，耗时   1,950ms 速度 164,102,564 ops
            删除 320,000,000 项， 32 线程，耗时   3,359ms 速度 95,266,448 ops
            
            测试 320,000,000 项， 64 线程
            赋值 320,000,000 项， 64 线程，耗时   9,648ms 速度 33,167,495 ops
            读取 320,000,000 项， 64 线程，耗时   1,974ms 速度 162,107,396 ops
            删除 320,000,000 项， 64 线程，耗时   1,907ms 速度 167,802,831 ops
            
            测试 320,000,000 项，256 线程
            赋值 320,000,000 项，256 线程，耗时  12,429ms 速度 25,746,238 ops
            读取 320,000,000 项，256 线程，耗时   1,907ms 速度 167,802,831 ops
            删除 320,000,000 项，256 线程，耗时   2,350ms 速度 136,170,212 ops
            </remarks>
        </member>
        <member name="M:NewLife.Caching.Cache.BenchOne(System.Int64,System.Int32,System.Boolean,System.Int32)">
            <summary>使用指定线程测试指定次数</summary>
            <param name="times">次数</param>
            <param name="threads">线程</param>
            <param name="rand">随机读写</param>
            <param name="batch">批量操作</param>
        </member>
        <member name="M:NewLife.Caching.Cache.BenchGet(System.String,System.Int64,System.Int32,System.Boolean,System.Int32)">
            <summary>读取测试</summary>
            <param name="key">键</param>
            <param name="times">次数</param>
            <param name="threads">线程</param>
            <param name="rand">随机读写</param>
            <param name="batch">批量操作</param>
        </member>
        <member name="M:NewLife.Caching.Cache.BenchSet(System.String,System.Int64,System.Int32,System.Boolean,System.Int32)">
            <summary>赋值测试</summary>
            <param name="key">键</param>
            <param name="times">次数</param>
            <param name="threads">线程</param>
            <param name="rand">随机读写</param>
            <param name="batch">批量操作</param>
        </member>
        <member name="M:NewLife.Caching.Cache.BenchInc(System.String,System.Int64,System.Int32,System.Boolean,System.Int32)">
            <summary>累加测试</summary>
            <param name="key">键</param>
            <param name="times">次数</param>
            <param name="threads">线程</param>
            <param name="rand">随机读写</param>
            <param name="batch">批量操作</param>
        </member>
        <member name="M:NewLife.Caching.Cache.BenchRemove(System.String,System.Int64,System.Int32,System.Boolean)">
            <summary>删除测试</summary>
            <param name="key">键</param>
            <param name="times">次数</param>
            <param name="threads">线程</param>
            <param name="rand">随机读写</param>
        </member>
        <member name="M:NewLife.Caching.Cache.ToString">
            <summary>已重载。</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Caching.CacheLock">
            <summary>分布式锁</summary>
        </member>
        <member name="P:NewLife.Caching.CacheLock.Key">
            <summary>键</summary>
        </member>
        <member name="M:NewLife.Caching.CacheLock.#ctor(NewLife.Caching.ICache,System.String)">
            <summary>实例化</summary>
            <param name="client"></param>
            <param name="key"></param>
        </member>
        <member name="M:NewLife.Caching.CacheLock.Acquire(System.Int32)">
            <summary>申请锁</summary>
            <param name="msTimeout"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.CacheLock.OnDispose(System.Boolean)">
            <summary>销毁</summary>
            <param name="disposing"></param>
        </member>
        <member name="T:NewLife.Caching.ICache">
            <summary>缓存接口</summary>
        </member>
        <member name="P:NewLife.Caching.ICache.Name">
            <summary>名称</summary>
        </member>
        <member name="P:NewLife.Caching.ICache.Expire">
            <summary>默认缓存时间。默认0秒表示不过期</summary>
        </member>
        <member name="P:NewLife.Caching.ICache.Item(System.String)">
            <summary>获取和设置缓存，永不过期</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Caching.ICache.Count">
            <summary>缓存个数</summary>
        </member>
        <member name="P:NewLife.Caching.ICache.Keys">
            <summary>所有键</summary>
        </member>
        <member name="M:NewLife.Caching.ICache.ContainsKey(System.String)">
            <summary>是否包含缓存项</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Set``1(System.String,``0,System.Int32)">
            <summary>设置缓存项</summary>
            <param name="key">键</param>
            <param name="value">值</param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.ICache.Expire"/></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Set``1(System.String,``0,System.TimeSpan)">
            <summary>设置缓存项</summary>
            <param name="key">键</param>
            <param name="value">值</param>
            <param name="expire">过期时间</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Get``1(System.String)">
            <summary>获取缓存项</summary>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Remove(System.String[])">
            <summary>批量移除缓存项</summary>
            <param name="keys">键集合</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Clear">
            <summary>清空所有缓存项</summary>
        </member>
        <member name="M:NewLife.Caching.ICache.SetExpire(System.String,System.TimeSpan)">
            <summary>设置缓存项有效期</summary>
            <param name="key">键</param>
            <param name="expire">过期时间</param>
        </member>
        <member name="M:NewLife.Caching.ICache.GetExpire(System.String)">
            <summary>获取缓存项有效期</summary>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.GetAll``1(System.Collections.Generic.IEnumerable{System.String})">
            <summary>批量获取缓存项</summary>
            <typeparam name="T"></typeparam>
            <param name="keys"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.SetAll``1(System.Collections.Generic.IDictionary{System.String,``0},System.Int32)">
            <summary>批量设置缓存项</summary>
            <typeparam name="T"></typeparam>
            <param name="values"></param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.ICache.Expire"/></param>
        </member>
        <member name="M:NewLife.Caching.ICache.GetList``1(System.String)">
            <summary>获取列表</summary>
            <typeparam name="T">元素类型</typeparam>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.GetDictionary``1(System.String)">
            <summary>获取哈希</summary>
            <typeparam name="T">元素类型</typeparam>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.GetQueue``1(System.String)">
            <summary>获取队列</summary>
            <typeparam name="T">元素类型</typeparam>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.GetSet``1(System.String)">
            <summary>获取Set</summary>
            <typeparam name="T"></typeparam>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Add``1(System.String,``0,System.Int32)">
            <summary>添加，已存在时不更新</summary>
            <typeparam name="T">值类型</typeparam>
            <param name="key">键</param>
            <param name="value">值</param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.Cache.Expire"/></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Replace``1(System.String,``0)">
            <summary>设置新值并获取旧值，原子操作</summary>
            <remarks>
            常常配合Increment使用，用于累加到一定数后重置归零，又避免多线程冲突。
            </remarks>
            <typeparam name="T">值类型</typeparam>
            <param name="key">键</param>
            <param name="value">值</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Increment(System.String,System.Int64)">
            <summary>累加，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Increment(System.String,System.Double)">
            <summary>累加，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Decrement(System.String,System.Int64)">
            <summary>递减，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Decrement(System.String,System.Double)">
            <summary>递减，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Commit">
            <summary>提交变更。部分提供者需要刷盘</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.AcquireLock(System.String,System.Int32)">
            <summary>申请分布式锁</summary>
            <param name="key">要锁定的key</param>
            <param name="msTimeout"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.ICache.Bench(System.Boolean,System.Int32)">
            <summary>多线程性能测试</summary>
            <param name="rand">随机读写</param>
            <param name="batch">批量操作。默认0不分批</param>
        </member>
        <member name="T:NewLife.Caching.IProducerConsumer`1">
            <summary>生产者消费者接口</summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="M:NewLife.Caching.IProducerConsumer`1.Add(System.Collections.Generic.IEnumerable{`0})">
            <summary>生产添加</summary>
            <param name="values"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.IProducerConsumer`1.Take(System.Int32)">
            <summary>消费获取</summary>
            <param name="count"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Caching.MemoryCache">
            <summary>默认字典缓存</summary>
        </member>
        <member name="F:NewLife.Caching.MemoryCache._cache">
            <summary>缓存核心</summary>
        </member>
        <member name="P:NewLife.Caching.MemoryCache.Capacity">
            <summary>容量。容量超标时，采用LRU机制删除，默认100_000</summary>
        </member>
        <member name="P:NewLife.Caching.MemoryCache.Period">
            <summary>定时清理时间，默认60秒</summary>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.#ctor">
            <summary>实例化一个内存字典缓存</summary>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.OnDispose(System.Boolean)">
            <summary>销毁</summary>
            <param name="disposing"></param>
        </member>
        <member name="P:NewLife.Caching.MemoryCache.Count">
            <summary>缓存项。原子计数</summary>
        </member>
        <member name="P:NewLife.Caching.MemoryCache.Keys">
            <summary>所有键。实际返回只读列表新实例，数据量较大时注意性能</summary>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.Init(System.String)">
            <summary>初始化配置</summary>
            <param name="config"></param>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.GetOrAdd``1(System.String,``0,System.Int32)">
            <summary>获取或添加缓存项</summary>
            <typeparam name="T">值类型</typeparam>
            <param name="key">键</param>
            <param name="value">值</param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.Cache.Expire"/></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.ContainsKey(System.String)">
            <summary>是否包含缓存项</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.Set``1(System.String,``0,System.Int32)">
            <summary>添加缓存项，已存在时更新</summary>
            <typeparam name="T">值类型</typeparam>
            <param name="key">键</param>
            <param name="value">值</param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.Cache.Expire"/></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.Get``1(System.String)">
            <summary>获取缓存项，不存在时返回默认值</summary>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.Remove(System.String[])">
            <summary>批量移除缓存项</summary>
            <param name="keys">键集合</param>
            <returns>实际移除个数</returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.Clear">
            <summary>清空所有缓存项</summary>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.SetExpire(System.String,System.TimeSpan)">
            <summary>设置缓存项有效期</summary>
            <param name="key">键</param>
            <param name="expire">过期时间</param>
            <returns>设置是否成功</returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.GetExpire(System.String)">
            <summary>获取缓存项有效期，不存在时返回Zero</summary>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.Add``1(System.String,``0,System.Int32)">
            <summary>添加，已存在时不更新，常用于锁争夺</summary>
            <typeparam name="T">值类型</typeparam>
            <param name="key">键</param>
            <param name="value">值</param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.Cache.Expire"/></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.Replace``1(System.String,``0)">
            <summary>设置新值并获取旧值，原子操作</summary>
            <typeparam name="T">值类型</typeparam>
            <param name="key">键</param>
            <param name="value">值</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.Increment(System.String,System.Int64)">
            <summary>累加，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.Increment(System.String,System.Double)">
            <summary>累加，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.Decrement(System.String,System.Int64)">
            <summary>递减，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.Decrement(System.String,System.Double)">
            <summary>递减，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.GetList``1(System.String)">
            <summary>获取列表</summary>
            <typeparam name="T"></typeparam>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.GetDictionary``1(System.String)">
            <summary>获取哈希</summary>
            <typeparam name="T"></typeparam>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.GetQueue``1(System.String)">
            <summary>获取队列</summary>
            <typeparam name="T"></typeparam>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.GetSet``1(System.String)">
            <summary>获取Set</summary>
            <remarks>基于HashSet，非线程安全</remarks>
            <typeparam name="T"></typeparam>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.GetOrAddItem(System.String,System.Func{System.String,System.Object})">
            <summary>获取 或 添加 缓存项</summary>
            <param name="key"></param>
            <param name="valueFactory"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Caching.MemoryCache.CacheItem">
            <summary>缓存项</summary>
        </member>
        <member name="P:NewLife.Caching.MemoryCache.CacheItem.Value">
            <summary>数值</summary>
        </member>
        <member name="P:NewLife.Caching.MemoryCache.CacheItem.ExpiredTime">
            <summary>过期时间</summary>
        </member>
        <member name="P:NewLife.Caching.MemoryCache.CacheItem.Expired">
            <summary>是否过期</summary>
        </member>
        <member name="P:NewLife.Caching.MemoryCache.CacheItem.VisitTime">
            <summary>访问时间</summary>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.CacheItem.#ctor(System.Object,System.Int32)">
            <summary>构造缓存项</summary>
            <param name="value"></param>
            <param name="expire"></param>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.CacheItem.Set(System.Object,System.Int32)">
            <summary>设置数值和过期时间</summary>
            <param name="value"></param>
            <param name="expire"></param>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.CacheItem.Visit">
            <summary>更新访问时间并返回数值</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.CacheItem.SetExpire(System.Int32)">
            <summary>设置过期时间</summary>
            <param name="expire"></param>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.CacheItem.Inc(System.Object)">
            <summary>递增</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.CacheItem.Dec(System.Object)">
            <summary>递减</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="F:NewLife.Caching.MemoryCache.clearTimer">
            <summary>清理会话计时器</summary>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.RemoveNotAlive(System.Object)">
            <summary>移除过期的缓存项</summary>
        </member>
        <member name="M:NewLife.Caching.MemoryCache.BenchOne(System.Int64,System.Int32,System.Boolean,System.Int32)">
            <summary>使用指定线程测试指定次数</summary>
            <param name="times">次数</param>
            <param name="threads">线程</param>
            <param name="rand">随机读写</param>
            <param name="batch">批量操作</param>
        </member>
        <member name="T:NewLife.Caching.MemoryQueue`1">
            <summary>生产者消费者</summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="M:NewLife.Caching.MemoryQueue`1.#ctor">
            <summary>实例化内存队列</summary>
        </member>
        <member name="M:NewLife.Caching.MemoryQueue`1.#ctor(System.Collections.Concurrent.IProducerConsumerCollection{`0})">
            <summary>实例化内存队列</summary>
            <param name="collection"></param>
        </member>
        <member name="M:NewLife.Caching.MemoryQueue`1.Add(System.Collections.Generic.IEnumerable{`0})">
            <summary>生产添加</summary>
            <param name="values"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.MemoryQueue`1.Take(System.Int32)">
            <summary>消费获取</summary>
            <param name="count"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Caching.Redis">
            <summary>Redis缓存</summary>
        </member>
        <member name="M:NewLife.Caching.Redis.Create(System.String,System.Int32)">
            <summary>创建指定服务器的实例</summary>
            <param name="server">服务器地址。支持前面加上密码，@分隔</param>
            <param name="db">使用的数据库</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Redis.Create(System.String,System.String,System.Int32)">
            <summary>创建指定服务器的实例，支持密码</summary>
            <param name="server">服务器地址。支持前面加上密码，@分隔</param>
            <param name="password">密码</param>
            <param name="db">使用的数据库</param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Caching.Redis.Server">
            <summary>服务器</summary>
        </member>
        <member name="P:NewLife.Caching.Redis.Password">
            <summary>密码</summary>
        </member>
        <member name="P:NewLife.Caching.Redis.Db">
            <summary>目标数据库。默认0</summary>
        </member>
        <member name="P:NewLife.Caching.Redis.Retry">
            <summary>出错重试次数。如果出现协议解析错误，可以重试的次数，默认3</summary>
        </member>
        <member name="P:NewLife.Caching.Redis.FullPipeline">
            <summary>完全管道。读取操作是否合并进入管道，默认false</summary>
        </member>
        <member name="P:NewLife.Caching.Redis.AutoPipeline">
            <summary>自动管道。管道操作达到一定数量时，自动提交，默认0</summary>
        </member>
        <member name="P:NewLife.Caching.Redis.Counter">
            <summary>性能计数器</summary>
        </member>
        <member name="M:NewLife.Caching.Redis.Init(System.String)">
            <summary>初始化</summary>
            <param name="config"></param>
        </member>
        <member name="M:NewLife.Caching.Redis.OnDispose(System.Boolean)">
            <summary>销毁</summary>
            <param name="disposing"></param>
        </member>
        <member name="M:NewLife.Caching.Redis.ToString">
            <summary>已重载。</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Redis.CreateSub(System.Int32)">
            <summary>为同一服务器创建不同Db的子级库</summary>
            <param name="db"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Caching.Redis.Pool">
            <summary>连接池</summary>
        </member>
        <member name="M:NewLife.Caching.Redis.Execute``1(System.String,System.Func{NewLife.Caching.RedisClient,``0},System.Boolean)">
            <summary>执行命令</summary>
            <typeparam name="TResult">返回类型</typeparam>
            <param name="key">命令key，用于选择集群节点</param>
            <param name="func">回调函数</param>
            <param name="write">是否写入操作</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Redis.StartPipeline">
            <summary>开始管道模式</summary>
        </member>
        <member name="M:NewLife.Caching.Redis.StopPipeline(System.Boolean)">
            <summary>结束管道模式</summary>
            <param name="requireResult">要求结果。默认false</param>
        </member>
        <member name="M:NewLife.Caching.Redis.Commit">
            <summary>提交变更。处理某些残留在管道里的命令</summary>
            <returns></returns>
        </member>
        <member name="P:NewLife.Caching.Redis.Count">
            <summary>缓存个数</summary>
        </member>
        <member name="P:NewLife.Caching.Redis.Keys">
            <summary>所有键</summary>
        </member>
        <member name="M:NewLife.Caching.Redis.Set``1(System.String,``0,System.Int32)">
            <summary>单个实体项</summary>
            <param name="key">键</param>
            <param name="value">值</param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.Cache.Expire"/></param>
        </member>
        <member name="M:NewLife.Caching.Redis.Get``1(System.String)">
            <summary>获取单体</summary>
            <param name="key">键</param>
        </member>
        <member name="M:NewLife.Caching.Redis.Remove(System.String[])">
            <summary>批量移除缓存项</summary>
            <param name="keys">键集合</param>
        </member>
        <member name="M:NewLife.Caching.Redis.Clear">
            <summary>清空所有缓存项</summary>
        </member>
        <member name="M:NewLife.Caching.Redis.ContainsKey(System.String)">
            <summary>是否存在</summary>
            <param name="key">键</param>
        </member>
        <member name="M:NewLife.Caching.Redis.SetExpire(System.String,System.TimeSpan)">
            <summary>设置缓存项有效期</summary>
            <param name="key">键</param>
            <param name="expire">过期时间</param>
        </member>
        <member name="M:NewLife.Caching.Redis.GetExpire(System.String)">
            <summary>获取缓存项有效期</summary>
            <param name="key">键</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Redis.GetAll``1(System.Collections.Generic.IEnumerable{System.String})">
            <summary>批量获取缓存项</summary>
            <typeparam name="T"></typeparam>
            <param name="keys"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Redis.SetAll``1(System.Collections.Generic.IDictionary{System.String,``0},System.Int32)">
            <summary>批量设置缓存项</summary>
            <typeparam name="T"></typeparam>
            <param name="values"></param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.Cache.Expire"/></param>
        </member>
        <member name="M:NewLife.Caching.Redis.Add``1(System.String,``0,System.Int32)">
            <summary>添加，已存在时不更新</summary>
            <typeparam name="T">值类型</typeparam>
            <param name="key">键</param>
            <param name="value">值</param>
            <param name="expire">过期时间，秒。小于0时采用默认缓存时间<seealso cref="P:NewLife.Caching.Cache.Expire"/></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Redis.Replace``1(System.String,``0)">
            <summary>设置新值并获取旧值，原子操作</summary>
            <typeparam name="T">值类型</typeparam>
            <param name="key">键</param>
            <param name="value">值</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Redis.Increment(System.String,System.Int64)">
            <summary>累加，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Redis.Increment(System.String,System.Double)">
            <summary>累加，原子操作，乘以100后按整数操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Redis.Decrement(System.String,System.Int64)">
            <summary>递减，原子操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Redis.Decrement(System.String,System.Double)">
            <summary>递减，原子操作，乘以100后按整数操作</summary>
            <param name="key">键</param>
            <param name="value">变化量</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.Redis.Bench(System.Boolean,System.Int32)">
            <summary>性能测试</summary>
            <remarks>
            Redis性能测试[随机]，批大小[100]，逻辑处理器 40 个 2,400MHz Intel(R) Xeon(R) CPU E5-2640 v4 @ 2.40GHz
            测试 100,000 项，  1 线程
            赋值 100,000 项，  1 线程，耗时     418ms 速度   239,234 ops
            读取 100,000 项，  1 线程，耗时     520ms 速度   192,307 ops
            删除 100,000 项，  1 线程，耗时     125ms 速度   800,000 ops
            测试 200,000 项，  2 线程
            赋值 200,000 项，  2 线程，耗时     548ms 速度   364,963 ops
            读取 200,000 项，  2 线程，耗时     549ms 速度   364,298 ops
            删除 200,000 项，  2 线程，耗时     315ms 速度   634,920 ops
            测试 400,000 项，  4 线程
            赋值 400,000 项，  4 线程，耗时     694ms 速度   576,368 ops
            读取 400,000 项，  4 线程，耗时     697ms 速度   573,888 ops
            删除 400,000 项，  4 线程，耗时     438ms 速度   913,242 ops
            测试 800,000 项，  8 线程
            赋值 800,000 项，  8 线程，耗时   1,206ms 速度   663,349 ops
            读取 800,000 项，  8 线程，耗时   1,236ms 速度   647,249 ops
            删除 800,000 项，  8 线程，耗时     791ms 速度 1,011,378 ops
            测试 4,000,000 项， 40 线程
            赋值 4,000,000 项， 40 线程，耗时   4,848ms 速度   825,082 ops
            读取 4,000,000 项， 40 线程，耗时   5,399ms 速度   740,877 ops
            删除 4,000,000 项， 40 线程，耗时   6,281ms 速度   636,841 ops
            测试 4,000,000 项， 64 线程
            赋值 4,000,000 项， 64 线程，耗时   6,806ms 速度   587,716 ops
            读取 4,000,000 项， 64 线程，耗时   5,365ms 速度   745,573 ops
            删除 4,000,000 项， 64 线程，耗时   6,716ms 速度   595,592 ops
            </remarks>
            <param name="rand">随机读写</param>
            <param name="batch">批量操作</param>
        </member>
        <member name="M:NewLife.Caching.Redis.BenchOne(System.Int64,System.Int32,System.Boolean,System.Int32)">
            <summary>使用指定线程测试指定次数</summary>
            <param name="times">次数</param>
            <param name="threads">线程</param>
            <param name="rand">随机读写</param>
            <param name="batch">批量操作</param>
        </member>
        <member name="P:NewLife.Caching.Redis.Log">
            <summary>日志</summary>
        </member>
        <member name="M:NewLife.Caching.Redis.WriteLog(System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="T:NewLife.Caching.RedisClient">
            <summary>Redis客户端</summary>
            <remarks>
            以极简原则进行设计，每个客户端不支持并行命令处理，可通过多客户端多线程解决。
            收发共用64k缓冲区，所以命令请求和响应不能超过64k。
            </remarks>
        </member>
        <member name="P:NewLife.Caching.RedisClient.Client">
            <summary>客户端</summary>
        </member>
        <member name="P:NewLife.Caching.RedisClient.Server">
            <summary>内容类型</summary>
        </member>
        <member name="P:NewLife.Caching.RedisClient.Password">
            <summary>密码</summary>
        </member>
        <member name="P:NewLife.Caching.RedisClient.Logined">
            <summary>是否已登录</summary>
        </member>
        <member name="P:NewLife.Caching.RedisClient.LoginTime">
            <summary>登录时间</summary>
        </member>
        <member name="P:NewLife.Caching.RedisClient.Busy">
            <summary>是否正在处理命令</summary>
        </member>
        <member name="M:NewLife.Caching.RedisClient.OnDispose(System.Boolean)">
            <summary>销毁</summary>
            <param name="disposing"></param>
        </member>
        <member name="M:NewLife.Caching.RedisClient.GetStream(System.Boolean)">
            <summary>异步请求</summary>
            <param name="create">新建连接</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.GetRequest(System.IO.Stream,System.String,NewLife.Data.Packet[])">
            <summary>发出请求</summary>
            <param name="ms"></param>
            <param name="cmd"></param>
            <param name="args"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.GetResponse(System.IO.Stream,System.Int32)">
            <summary>接收响应</summary>
            <param name="ns"></param>
            <param name="count"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.ExecuteCommand(System.String,NewLife.Data.Packet[])">
            <summary>发出请求</summary>
            <param name="cmd"></param>
            <param name="args"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.Reset">
            <summary>重置。干掉历史残留数据</summary>
        </member>
        <member name="M:NewLife.Caching.RedisClient.Execute(System.String,System.Object[])">
            <summary>执行命令。返回字符串、Packet、Packet[]</summary>
            <param name="cmd"></param>
            <param name="args"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.Execute``1(System.String,System.Object[])">
            <summary>执行命令。返回基本类型、对象、对象数组</summary>
            <param name="cmd"></param>
            <param name="args"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.TryChangeType(System.Object,System.Type,System.Object@)">
            <summary>尝试转换类型</summary>
            <param name="value"></param>
            <param name="type"></param>
            <param name="target"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Caching.RedisClient.PipelineCommands">
            <summary>管道命令个数</summary>
        </member>
        <member name="M:NewLife.Caching.RedisClient.StartPipeline">
            <summary>开始管道模式</summary>
        </member>
        <member name="M:NewLife.Caching.RedisClient.StopPipeline(System.Boolean)">
            <summary>结束管道模式</summary>
            <param name="requireResult">要求结果</param>
        </member>
        <member name="M:NewLife.Caching.RedisClient.Ping">
            <summary>心跳</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.Select(System.Int32)">
            <summary>选择Db</summary>
            <param name="db"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.Auth(System.String)">
            <summary>验证密码</summary>
            <param name="password"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.Quit">
            <summary>退出</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.GetInfo">
            <summary>获取信息</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.Set``1(System.String,``0,System.Int32)">
            <summary>设置</summary>
            <typeparam name="T"></typeparam>
            <param name="key"></param>
            <param name="value"></param>
            <param name="secTimeout">超时时间</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.Get``1(System.String)">
            <summary>读取</summary>
            <typeparam name="T"></typeparam>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.SetAll``1(System.Collections.Generic.IDictionary{System.String,``0})">
            <summary>批量设置</summary>
            <typeparam name="T"></typeparam>
            <param name="values"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.GetAll``1(System.Collections.Generic.IEnumerable{System.String})">
            <summary>批量获取</summary>
            <typeparam name="T"></typeparam>
            <param name="keys"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.ToBytes(System.Object)">
            <summary>数值转字节数组</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.FromBytes(NewLife.Data.Packet,System.Type)">
            <summary>字节数组转对象</summary>
            <param name="pk"></param>
            <param name="type"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.FromBytes``1(NewLife.Data.Packet)">
            <summary>字节数组转对象</summary>
            <typeparam name="T"></typeparam>
            <param name="pk"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Caching.RedisClient.GetHeaderBytes(System.String,System.Int32)">
            <summary>获取命令对应的字节数组，全局缓存</summary>
            <param name="cmd"></param>
            <param name="args"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Caching.RedisClient.Log">
            <summary>日志</summary>
        </member>
        <member name="M:NewLife.Caching.RedisClient.WriteLog(System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="T:NewLife.Collections.ConcurrentHashSet`1">
            <summary>并行哈希集合</summary>
            <remarks>
            主要用于频繁添加删除而又要遍历的场合
            </remarks>
        </member>
        <member name="P:NewLife.Collections.ConcurrentHashSet`1.IsEmpty">
            <summary>是否空集合</summary>
        </member>
        <member name="P:NewLife.Collections.ConcurrentHashSet`1.Count">
            <summary>元素个数</summary>
        </member>
        <member name="M:NewLife.Collections.ConcurrentHashSet`1.Contain(`0)">
            <summary>是否包含元素</summary>
            <param name="item"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.ConcurrentHashSet`1.TryAdd(`0)">
            <summary>尝试添加</summary>
            <param name="item"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.ConcurrentHashSet`1.TryRemove(`0)">
            <summary>尝试删除</summary>
            <param name="item"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Collections.DictionaryCache`2">
            <summary>字典缓存。当指定键的缓存项不存在时，调用委托获取值，并写入缓存。</summary>
            <remarks>常用匿名函数或者Lambda表达式作为委托。</remarks>
            <typeparam name="TKey">键类型</typeparam>
            <typeparam name="TValue">值类型</typeparam>
        </member>
        <member name="P:NewLife.Collections.DictionaryCache`2.Expire">
            <summary>过期时间。单位是秒，默认0秒，表示永不过期</summary>
        </member>
        <member name="P:NewLife.Collections.DictionaryCache`2.Period">
            <summary>定时清理时间，默认0秒，表示不清理过期项</summary>
        </member>
        <member name="P:NewLife.Collections.DictionaryCache`2.Capacity">
            <summary>容量。容量超标时，采用LRU机制删除，默认10_000</summary>
        </member>
        <member name="P:NewLife.Collections.DictionaryCache`2.AllowNull">
            <summary>是否允许缓存控制，避免缓存穿透。默认false</summary>
        </member>
        <member name="P:NewLife.Collections.DictionaryCache`2.FindMethod">
            <summary>查找数据的方法</summary>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.#ctor">
            <summary>实例化一个字典缓存</summary>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.#ctor(System.Collections.Generic.IEqualityComparer{`0})">
            <summary>实例化一个字典缓存</summary>
            <param name="comparer"></param>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.#ctor(System.Func{`0,`1},System.Collections.Generic.IEqualityComparer{`0})">
            <summary>实例化一个字典缓存</summary>
            <param name="findMethod"></param>
            <param name="comparer"></param>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.OnDispose(System.Boolean)">
            <summary>销毁</summary>
            <param name="disposing"></param>
        </member>
        <member name="T:NewLife.Collections.DictionaryCache`2.CacheItem">
            <summary>缓存项</summary>
        </member>
        <member name="P:NewLife.Collections.DictionaryCache`2.CacheItem.Value">
            <summary>数值</summary>
        </member>
        <member name="P:NewLife.Collections.DictionaryCache`2.CacheItem.ExpiredTime">
            <summary>过期时间</summary>
        </member>
        <member name="P:NewLife.Collections.DictionaryCache`2.CacheItem.Expired">
            <summary>是否过期</summary>
        </member>
        <member name="P:NewLife.Collections.DictionaryCache`2.CacheItem.VisitTime">
            <summary>访问时间</summary>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.CacheItem.Visit">
            <summary>更新访问时间并返回数值</summary>
            <returns></returns>
        </member>
        <member name="P:NewLife.Collections.DictionaryCache`2.Item(`0)">
            <summary>重写索引器。取值时如果没有该项则返回默认值；赋值时如果已存在该项则覆盖，否则添加。</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.GetOrAdd(`0)">
            <summary>获取 GetOrAdd</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.Get(`0)">
            <summary>获取 GetOrAdd</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.Set(`0,`1)">
            <summary>设置 AddOrUpdate</summary>
            <param name="key"></param>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.TryAdd(`0,`1,System.Boolean,`1@)">
            <summary>尝试添加，或返回旧值</summary>
            <param name="key"></param>
            <param name="value"></param>
            <param name="updateIfExists"></param>
            <param name="resultingValue"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.GetItem(`0,System.Func{`0,`1})">
            <summary>扩展获取数据项，当数据项不存在时，通过调用委托获取数据项。线程安全。</summary>
            <param name="key">键</param>
            <param name="func">获取值的委托，该委托以键作为参数</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.Remove(`0)">
            <summary>移除指定缓存项</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.Clear">
            <summary>清空</summary>
        </member>
        <member name="P:NewLife.Collections.DictionaryCache`2.Count">
            <summary>缓存项。原子计数</summary>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.ContainsKey(`0)">
            <summary>是否包含指定键</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.CopyTo(NewLife.Collections.DictionaryCache{`0,`1})">
            <summary>赋值到目标缓存</summary>
            <param name="cache"></param>
        </member>
        <member name="F:NewLife.Collections.DictionaryCache`2._timer">
            <summary>清理会话计时器</summary>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.RemoveNotAlive(System.Object)">
            <summary>移除过期的缓存项</summary>
        </member>
        <member name="M:NewLife.Collections.DictionaryCache`2.GetEnumerator">
            <summary>枚举</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Collections.ICluster`2">
            <summary>集群管理</summary>
            <typeparam name="TKey"></typeparam>
            <typeparam name="TValue"></typeparam>
        </member>
        <member name="P:NewLife.Collections.ICluster`2.GetItems">
            <summary>资源列表</summary>
        </member>
        <member name="M:NewLife.Collections.ICluster`2.Open">
            <summary>打开</summary>
        </member>
        <member name="M:NewLife.Collections.ICluster`2.Close(System.String)">
            <summary>关闭</summary>
            <param name="reason">关闭原因。便于日志分析</param>
            <returns>是否成功</returns>
        </member>
        <member name="M:NewLife.Collections.ICluster`2.Get">
            <summary>从集群中获取资源</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.ICluster`2.Put(`1)">
            <summary>归还</summary>
            <param name="value"></param>
        </member>
        <member name="T:NewLife.Collections.ClusterException">
            <summary>集群异常</summary>
        </member>
        <member name="P:NewLife.Collections.ClusterException.Resource">
            <summary>资源</summary>
        </member>
        <member name="M:NewLife.Collections.ClusterException.#ctor(System.String,System.Exception)">
            <summary>实例化</summary>
            <param name="res"></param>
            <param name="inner"></param>
        </member>
        <member name="T:NewLife.Collections.ClusterHelper">
            <summary>集群助手</summary>
        </member>
        <member name="M:NewLife.Collections.ClusterHelper.Invoke``3(NewLife.Collections.ICluster{``0,``1},System.Func{``1,``2})">
            <summary>借助集群资源处理事务</summary>
            <typeparam name="TKey"></typeparam>
            <typeparam name="TValue"></typeparam>
            <typeparam name="TResult"></typeparam>
            <param name="cluster"></param>
            <param name="func"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.ClusterHelper.InvokeAll``3(NewLife.Collections.ICluster{``0,``1},System.Func{``1,``2})">
            <summary>对集群进行多次调用</summary>
            <typeparam name="TKey"></typeparam>
            <typeparam name="TValue"></typeparam>
            <typeparam name="TResult"></typeparam>
            <param name="cluster"></param>
            <param name="func"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Collections.IPool`1">
            <summary>对象池接口</summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="P:NewLife.Collections.IPool`1.Max">
            <summary>对象池大小</summary>
        </member>
        <member name="M:NewLife.Collections.IPool`1.Get">
            <summary>获取</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.IPool`1.Put(`0)">
            <summary>归还</summary>
            <param name="value"></param>
        </member>
        <member name="M:NewLife.Collections.IPool`1.Clear">
            <summary>清空</summary>
        </member>
        <member name="T:NewLife.Collections.Pool">
            <summary>对象池扩展</summary>
        </member>
        <member name="P:NewLife.Collections.Pool.StringBuilder">
            <summary>字符串构建器池</summary>
        </member>
        <member name="M:NewLife.Collections.Pool.Put(System.Text.StringBuilder,System.Boolean)">
            <summary>归还一个字符串构建器到对象池</summary>
            <param name="sb"></param>
            <param name="requireResult">是否需要返回结果</param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Collections.Pool.StringBuilderPool">
            <summary>字符串构建器池</summary>
        </member>
        <member name="P:NewLife.Collections.Pool.StringBuilderPool.InitialCapacity">
            <summary>初始容量。默认100个</summary>
        </member>
        <member name="P:NewLife.Collections.Pool.StringBuilderPool.MaximumCapacity">
            <summary>最大容量。超过该大小时不进入池内，默认4k</summary>
        </member>
        <member name="M:NewLife.Collections.Pool.StringBuilderPool.OnCreate">
            <summary>创建</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.Pool.StringBuilderPool.Put(System.Text.StringBuilder)">
            <summary>归还</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Collections.Pool.MemoryStream">
            <summary>内存流池</summary>
        </member>
        <member name="M:NewLife.Collections.Pool.Put(System.IO.MemoryStream,System.Boolean)">
            <summary>归还一个内存流到对象池</summary>
            <param name="ms"></param>
            <param name="requireResult">是否需要返回结果</param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Collections.Pool.MemoryStreamPool">
            <summary>内存流池</summary>
        </member>
        <member name="P:NewLife.Collections.Pool.MemoryStreamPool.InitialCapacity">
            <summary>初始容量。默认1024个</summary>
        </member>
        <member name="P:NewLife.Collections.Pool.MemoryStreamPool.MaximumCapacity">
            <summary>最大容量。超过该大小时不进入池内，默认64k</summary>
        </member>
        <member name="M:NewLife.Collections.Pool.MemoryStreamPool.OnCreate">
            <summary>创建</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.Pool.MemoryStreamPool.Put(System.IO.MemoryStream)">
            <summary>归还</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Collections.NullableDictionary`2">
            <summary>可空字典。获取数据时如果指定键不存在可返回空而不是抛出异常</summary>
            <typeparam name="TKey"></typeparam>
            <typeparam name="TValue"></typeparam>
        </member>
        <member name="M:NewLife.Collections.NullableDictionary`2.#ctor">
            <summary>实例化一个可空字典</summary>
        </member>
        <member name="M:NewLife.Collections.NullableDictionary`2.#ctor(System.Collections.Generic.IEqualityComparer{`0})">
            <summary>指定比较器实例化一个可空字典</summary>
            <param name="comparer"></param>
        </member>
        <member name="M:NewLife.Collections.NullableDictionary`2.#ctor(System.Collections.Generic.IDictionary{`0,`1},System.Collections.Generic.IEqualityComparer{`0})">
            <summary>实例化一个可空字典</summary>
            <param name="dic"></param>
            <param name="comparer"></param>
        </member>
        <member name="P:NewLife.Collections.NullableDictionary`2.Item(`0)">
            <summary>获取或设置与指定的属性是否有脏数据。</summary>
            <param name="item"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Collections.ObjectPool`1">
            <summary>资源池。支持空闲释放，主要用于数据库连接池和网络连接池</summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.Name">
            <summary>名称</summary>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.FreeCount">
            <summary>空闲个数</summary>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.BusyCount">
            <summary>繁忙个数</summary>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.Max">
            <summary>最大个数。默认100，0表示无上限</summary>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.Min">
            <summary>最小个数。默认1</summary>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.IdleTime">
            <summary>空闲清理时间。最小个数之上的资源超过空闲时间时被清理，默认10s</summary>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.AllIdleTime">
            <summary>完全空闲清理时间。最小个数之下的资源超过空闲时间时被清理，默认0s永不清理</summary>
        </member>
        <member name="F:NewLife.Collections.ObjectPool`1._free">
            <summary>基础空闲集合。只保存最小个数，最热部分</summary>
        </member>
        <member name="F:NewLife.Collections.ObjectPool`1._free2">
            <summary>扩展空闲集合。保存最小个数以外部分</summary>
        </member>
        <member name="F:NewLife.Collections.ObjectPool`1._busy">
            <summary>借出去的放在这</summary>
        </member>
        <member name="M:NewLife.Collections.ObjectPool`1.#ctor">
            <summary>实例化一个资源池</summary>
        </member>
        <member name="M:NewLife.Collections.ObjectPool`1.OnDispose(System.Boolean)">
            <summary>销毁</summary>
            <param name="disposing"></param>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.Item.Value">
            <summary>数值</summary>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.Item.LastTime">
            <summary>过期时间</summary>
        </member>
        <member name="M:NewLife.Collections.ObjectPool`1.Get">
            <summary>借出</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.ObjectPool`1.OnGet(`0)">
            <summary>借出时是否可用</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.ObjectPool`1.GetItem">
            <summary>申请资源包装项，Dispose时自动归还到池中</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.ObjectPool`1.Put(`0)">
            <summary>归还</summary>
            <param name="value"></param>
        </member>
        <member name="M:NewLife.Collections.ObjectPool`1.OnPut(`0)">
            <summary>归还时是否可用</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.ObjectPool`1.Clear">
            <summary>清空已有对象</summary>
        </member>
        <member name="M:NewLife.Collections.ObjectPool`1.OnDispose(`0)">
            <summary>销毁</summary>
            <param name="value"></param>
        </member>
        <member name="M:NewLife.Collections.ObjectPool`1.OnCreate">
            <summary>创建实例</summary>
            <returns></returns>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.Total">
            <summary>总请求数</summary>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.Success">
            <summary>成功数</summary>
        </member>
        <member name="F:NewLife.Collections.ObjectPool`1._NewCount">
            <summary>新创建数</summary>
        </member>
        <member name="F:NewLife.Collections.ObjectPool`1._ReleaseCount">
            <summary>释放数</summary>
        </member>
        <member name="F:NewLife.Collections.ObjectPool`1.Cost">
            <summary>平均耗时。单位ms</summary>
        </member>
        <member name="P:NewLife.Collections.ObjectPool`1.Log">
            <summary>日志</summary>
        </member>
        <member name="M:NewLife.Collections.ObjectPool`1.WriteLog(System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="T:NewLife.Collections.PoolItem`1">
            <summary>资源池包装项，自动归还资源到池中</summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="P:NewLife.Collections.PoolItem`1.Value">
            <summary>数值</summary>
        </member>
        <member name="P:NewLife.Collections.PoolItem`1.Pool">
            <summary>池</summary>
        </member>
        <member name="M:NewLife.Collections.PoolItem`1.#ctor(NewLife.Collections.IPool{`0},`0)">
            <summary>包装项</summary>
            <param name="pool"></param>
            <param name="value"></param>
        </member>
        <member name="M:NewLife.Collections.PoolItem`1.OnDispose(System.Boolean)">
            <summary>销毁</summary>
            <param name="disposing"></param>
        </member>
        <member name="T:NewLife.Collections.Pool`1">
            <summary>轻量级对象池。数组无锁实现，高性能</summary>
            <remarks>
            内部 1+N 的存储结果，保留最热的一个对象在外层，便于快速存取。
            数组具有极快的查找速度，结构体确保没有GC操作。
            </remarks>
            <typeparam name="T"></typeparam>
        </member>
        <member name="P:NewLife.Collections.Pool`1.Max">
            <summary>对象池大小。默认CPU*2，初始化后改变无效</summary>
        </member>
        <member name="M:NewLife.Collections.Pool`1.#ctor(System.Int32)">
            <summary>实例化对象池。默认大小CPU*2</summary>
            <param name="max"></param>
        </member>
        <member name="M:NewLife.Collections.Pool`1.Get">
            <summary>获取</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.Pool`1.Put(`0)">
            <summary>归还</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.Pool`1.Clear">
            <summary>清空</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Collections.Pool`1.OnCreate">
            <summary>创建实例</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.IDisposable2">
            <summary>具有是否已释放和释放后事件的接口</summary>
        </member>
        <member name="P:NewLife.IDisposable2.Disposed">
            <summary>是否已经释放</summary>
        </member>
        <member name="E:NewLife.IDisposable2.OnDisposed">
            <summary>被销毁时触发事件</summary>
        </member>
        <member name="T:NewLife.DisposeBase">
            <summary>具有销毁资源处理的抽象基类</summary>
            <example>
            <code>
            /// &lt;summary&gt;子类重载实现资源释放逻辑时必须首先调用基类方法&lt;/summary&gt;
            /// &lt;param name="disposing"&gt;从Dispose调用（释放所有资源）还是析构函数调用（释放非托管资源）。
            /// 因为该方法只会被调用一次，所以该参数的意义不太大。&lt;/param&gt;
            protected override void OnDispose(bool disposing)
            {
                base.OnDispose(disposing);
            
                if (disposing)
                {
                    // 如果是构造函数进来，不执行这里的代码
                }
            }
            </code>
            </example>
        </member>
        <member name="M:NewLife.DisposeBase.Dispose">
            <summary>释放资源</summary>
        </member>
        <member name="P:NewLife.DisposeBase.Disposed">
            <summary>是否已经释放</summary>
        </member>
        <member name="E:NewLife.DisposeBase.OnDisposed">
            <summary>被销毁时触发事件</summary>
        </member>
        <member name="M:NewLife.DisposeBase.Dispose(System.Boolean)">
            <summary>释放资源，参数表示是否由Dispose调用。该方法保证OnDispose只被调用一次！</summary>
            <param name="disposing"></param>
        </member>
        <member name="M:NewLife.DisposeBase.OnDispose(System.Boolean)">
            <summary>子类重载实现资源释放逻辑时必须首先调用基类方法</summary>
            <param name="disposing">从Dispose调用（释放所有资源）还是析构函数调用（释放非托管资源）。
            因为该方法只会被调用一次，所以该参数的意义不太大。</param>
        </member>
        <member name="M:NewLife.DisposeBase.Finalize">
            <summary>析构函数</summary>
            <remarks>
            如果忘记调用Dispose，这里会释放非托管资源
            如果曾经调用过Dispose，因为GC.SuppressFinalize(this)，不会再调用该析构函数
            </remarks>
        </member>
        <member name="T:NewLife.DisposeHelper">
            <summary>销毁助手。扩展方法专用</summary>
        </member>
        <member name="M:NewLife.DisposeHelper.TryDispose(System.Object)">
            <summary>尝试销毁对象，如果有<see cref="T:System.IDisposable"/>则调用</summary>
            <param name="obj"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Common.PinYin">
            <summary>汉字拼音转换类</summary>
        </member>
        <member name="M:NewLife.Common.PinYin.GetFirst(System.Char)">
            <summary>取拼音第一个字段</summary>        
            <param name="ch"></param>        
            <returns></returns>        
        </member>
        <member name="M:NewLife.Common.PinYin.GetFirst(System.String)">
            <summary>取拼音第一个字段</summary>
            <param name="str"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Common.PinYin.GetFirstOne(System.String)">
            <summary>取拼音第一个字段</summary>
            <param name="str"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Common.PinYin.Get(System.Char)">
            <summary>获取单字拼音</summary>
            <param name="ch"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Common.PinYin.Get(System.String)">
            <summary>把汉字转换成拼音(全拼)</summary>
            <param name="str">汉字字符串</param>
            <returns>转换后的拼音(全拼)字符串</returns>
        </member>
        <member name="T:NewLife.Common.SysConfig">
            <summary>系统设置。提供系统名称、版本等基本设置。</summary>
        </member>
        <member name="T:NewLife.Common.SysConfig`1">
            <summary>系统设置。提供系统名称、版本等基本设置。泛型基类，可继承扩展。</summary>
            <typeparam name="TSetting"></typeparam>
        </member>
        <member name="P:NewLife.Common.SysConfig`1.Name">
            <summary>系统名称</summary>
        </member>
        <member name="P:NewLife.Common.SysConfig`1.Version">
            <summary>系统版本</summary>
        </member>
        <member name="P:NewLife.Common.SysConfig`1.DisplayName">
            <summary>显示名称</summary>
        </member>
        <member name="P:NewLife.Common.SysConfig`1.Company">
            <summary>公司</summary>
        </member>
        <member name="P:NewLife.Common.SysConfig`1.Develop">
            <summary>开发者模式</summary>
        </member>
        <member name="P:NewLife.Common.SysConfig`1.Enable">
            <summary>启用</summary>
        </member>
        <member name="P:NewLife.Common.SysConfig`1.InstallTime">
            <summary>安装时间</summary>
        </member>
        <member name="M:NewLife.Common.SysConfig`1.#ctor">
            <summary>实例化</summary>
        </member>
        <member name="M:NewLife.Common.SysConfig`1.OnNew">
            <summary>新建配置</summary>
        </member>
        <member name="P:NewLife.Common.SysConfig`1.SysAssembly">
            <summary>系统主程序集</summary>
        </member>
        <member name="T:NewLife.Runtime">
            <summary>运行时</summary>
        </member>
        <member name="P:NewLife.Runtime.IsConsole">
            <summary>是否控制台。用于判断是否可以执行一些控制台操作。</summary>
        </member>
        <member name="P:NewLife.Runtime.Mono">
            <summary>是否Mono环境</summary>
        </member>
        <member name="P:NewLife.Runtime.IsWeb">
            <summary>是否Web环境</summary>
        </member>
        <member name="P:NewLife.Runtime.Windows">
            <summary>是否Windows环境</summary>
        </member>
        <member name="P:NewLife.Runtime.Linux">
            <summary>是否Linux环境</summary>
        </member>
        <member name="P:NewLife.Runtime.OSX">
            <summary>是否OSX环境</summary>
        </member>
        <member name="T:NewLife.Compression.SevenZip">
            <summary>7Zip</summary>
        </member>
        <member name="M:NewLife.Compression.SevenZip.#ctor">
            <summary>实例化</summary>
        </member>
        <member name="M:NewLife.Compression.SevenZip.Compress(System.String,System.String)">
            <summary>压缩文件</summary>
            <param name="path"></param>
            <param name="destFile"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Compression.SevenZip.Extract(System.String,System.String,System.Boolean)">
            <summary>解压缩文件</summary>
            <param name="file"></param>
            <param name="destDir"></param>
            <param name="overwrite">是否覆盖目标同名文件</param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Compression.SevenZip.Log">
            <summary>日志</summary>
        </member>
        <member name="M:NewLife.Compression.SevenZip.WriteLog(System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="T:NewLife.Data.BinaryTree">
            <summary>二叉树</summary>
        </member>
        <member name="M:NewLife.Data.BinaryTree.GetAll(System.Int32)">
            <summary>遍历所有二叉树</summary>
            <param name="size"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.BinaryTree.Build(NewLife.Data.BinaryTree.Node,System.Double[],System.Collections.Generic.List{System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression}},System.Collections.Generic.List{System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression}})">
            <summary>构建表达式树</summary>
            <param name="node"></param>
            <param name="numbers"></param>
            <param name="ops"></param>
            <param name="sops"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.BinaryTree.FullPermute``1(``0[])">
            <summary>遍历全排列</summary>
            <typeparam name="T"></typeparam>
            <param name="arr"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.BinaryTree.OperatorPermute(System.Collections.Generic.List{System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression}},System.Int32)">
            <summary>从4种运算符中挑选3个运算符</summary>
            <param name="operators"></param>
            <param name="count"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.BinaryTree.Cbrt(System.Double)">
            <summary>立方根</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.BinaryTree.Execute(System.Double[],System.Double)">
            <summary>数学运算</summary>
            <param name="numbers"></param>
            <param name="result"></param>
        </member>
        <member name="T:NewLife.Data.DbRow">
            <summary>数据行</summary>
        </member>
        <member name="P:NewLife.Data.DbRow.Table">
            <summary>数据表</summary>
        </member>
        <member name="P:NewLife.Data.DbRow.Index">
            <summary>行索引</summary>
        </member>
        <member name="M:NewLife.Data.DbRow.#ctor(NewLife.Data.DbTable,System.Int32)">
            <summary>构造数据行</summary>
            <param name="table"></param>
            <param name="index"></param>
        </member>
        <member name="P:NewLife.Data.DbRow.Item(System.Int32)">
            <summary>基于列索引访问</summary>
            <param name="column"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Data.DbRow.Item(System.String)">
            <summary>基于列名访问</summary>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.DbRow.Get``1(System.String)">
            <summary>读取指定行的字段值</summary>
            <typeparam name="T"></typeparam>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Data.DbTable">
            <summary>数据表</summary>
        </member>
        <member name="P:NewLife.Data.DbTable.Columns">
            <summary>数据列</summary>
        </member>
        <member name="P:NewLife.Data.DbTable.Types">
            <summary>数据列类型</summary>
        </member>
        <member name="P:NewLife.Data.DbTable.Rows">
            <summary>数据行</summary>
        </member>
        <member name="P:NewLife.Data.DbTable.Total">
            <summary>总函数</summary>
        </member>
        <member name="M:NewLife.Data.DbTable.Read(System.Data.IDataReader)">
            <summary>读取数据</summary>
            <param name="dr"></param>
        </member>
        <member name="M:NewLife.Data.DbTable.Read(System.IO.Stream)">
            <summary>从数据流读取</summary>
            <param name="stream"></param>
        </member>
        <member name="M:NewLife.Data.DbTable.ReadHeader(NewLife.Serialization.Binary)">
            <summary>读取头部</summary>
            <param name="bn"></param>
        </member>
        <member name="M:NewLife.Data.DbTable.ReadData(NewLife.Serialization.Binary,System.Int32)">
            <summary>读取数据</summary>
            <param name="bn"></param>
            <param name="rows"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.DbTable.Read(NewLife.Data.Packet)">
            <summary>读取</summary>
            <param name="pk"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.DbTable.LoadFile(System.String)">
            <summary>从文件加载</summary>
            <param name="file"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.DbTable.Write(System.IO.Stream)">
            <summary>写入数据流</summary>
            <param name="stream"></param>
        </member>
        <member name="M:NewLife.Data.DbTable.WriteHeader(NewLife.Serialization.Binary)">
            <summary>写入头部到数据流</summary>
            <param name="bn"></param>
        </member>
        <member name="M:NewLife.Data.DbTable.WriteData(NewLife.Serialization.Binary)">
            <summary>写入数据部分到数据流</summary>
            <param name="bn"></param>
        </member>
        <member name="M:NewLife.Data.DbTable.ToPacket">
            <summary>转数据包</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.DbTable.SaveFile(System.String)">
            <summary>保存到文件</summary>
            <param name="file"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.DbTable.Get``1(System.Int32,System.String)">
            <summary>读取指定行的字段值</summary>
            <typeparam name="T"></typeparam>
            <param name="row"></param>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.DbTable.TryGet``1(System.Int32,System.String,``0@)">
            <summary>尝试读取指定行的字段值</summary>
            <typeparam name="T"></typeparam>
            <param name="row"></param>
            <param name="name"></param>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.DbTable.GetColumn(System.String)">
            <summary>根据名称找字段序号</summary>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.DbTable.ToString">
            <summary>数据集</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.DbTable.Clone">
            <summary>克隆</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.DbTable.GetEnumerator">
            <summary>获取枚举</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Data.GeoAddress">
            <summary>地理地址</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Name">
            <summary>名称</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Location">
            <summary>坐标</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Address">
            <summary>地址</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Code">
            <summary>行政区域编码</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Country">
            <summary>国家</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Province">
            <summary>省份</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.City">
            <summary>城市</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.District">
            <summary>区县</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Township">
            <summary>乡镇</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Towncode">
            <summary>乡镇编码</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Street">
            <summary>街道</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.StreetNumber">
            <summary></summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Level">
            <summary>级别</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Precise">
            <summary>精确打点</summary>
        </member>
        <member name="P:NewLife.Data.GeoAddress.Confidence">
            <summary>可信度。[0-100]</summary>
        </member>
        <member name="M:NewLife.Data.GeoAddress.ToString">
            <summary>已重载。</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Data.GeoArea">
            <summary>地理区域</summary>
        </member>
        <member name="P:NewLife.Data.GeoArea.Code">
            <summary>编码</summary>
        </member>
        <member name="P:NewLife.Data.GeoArea.Name">
            <summary>名称</summary>
        </member>
        <member name="P:NewLife.Data.GeoArea.ParentCode">
            <summary>父级</summary>
        </member>
        <member name="P:NewLife.Data.GeoArea.Center">
            <summary>中心</summary>
        </member>
        <member name="P:NewLife.Data.GeoArea.Polyline">
            <summary>边界</summary>
        </member>
        <member name="P:NewLife.Data.GeoArea.Level">
            <summary>级别</summary>
        </member>
        <member name="M:NewLife.Data.GeoArea.ToString">
            <summary>已重载。</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Data.GeoPoint">
            <summary>经纬度坐标</summary>
        </member>
        <member name="P:NewLife.Data.GeoPoint.Longitude">
            <summary>经度</summary>
        </member>
        <member name="P:NewLife.Data.GeoPoint.Latitude">
            <summary>纬度</summary>
        </member>
        <member name="M:NewLife.Data.GeoPoint.#ctor">
            <summary>经纬度坐标</summary>
        </member>
        <member name="M:NewLife.Data.GeoPoint.#ctor(System.String)">
            <summary>经纬度坐标</summary>
            <param name="location"></param>
        </member>
        <member name="M:NewLife.Data.GeoPoint.ToString">
            <summary>已重载</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Data.IData">
            <summary>数据帧接口</summary>
        </member>
        <member name="P:NewLife.Data.IData.Packet">
            <summary>数据包</summary>
        </member>
        <member name="P:NewLife.Data.IData.Remote">
            <summary>远程地址</summary>
        </member>
        <member name="P:NewLife.Data.IData.Message">
            <summary>消息</summary>
        </member>
        <member name="P:NewLife.Data.IData.UserState">
            <summary>用户数据</summary>
        </member>
        <member name="T:NewLife.Data.IExtend">
            <summary>具有扩展数据的接口</summary>
        </member>
        <member name="P:NewLife.Data.IExtend.Items">
            <summary>数据项</summary>
        </member>
        <member name="P:NewLife.Data.IExtend.Item(System.String)">
            <summary>设置 或 获取 数据项</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Data.IFilter">
            <summary>数据过滤器</summary>
        </member>
        <member name="P:NewLife.Data.IFilter.Next">
            <summary>下一个过滤器</summary>
        </member>
        <member name="M:NewLife.Data.IFilter.Execute(NewLife.Data.FilterContext)">
            <summary>对封包执行过滤器</summary>
            <param name="context"></param>
        </member>
        <member name="T:NewLife.Data.FilterContext">
            <summary>过滤器上下文</summary>
        </member>
        <member name="P:NewLife.Data.FilterContext.Packet">
            <summary>封包</summary>
        </member>
        <member name="T:NewLife.Data.FilterHelper">
            <summary>过滤器助手</summary>
        </member>
        <member name="M:NewLife.Data.FilterHelper.Find(NewLife.Data.IFilter,System.Type)">
            <summary>在链条里面查找指定类型的过滤器</summary>
            <param name="filter"></param>
            <param name="filterType"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Data.FilterBase">
            <summary>数据过滤器基类</summary>
        </member>
        <member name="P:NewLife.Data.FilterBase.Next">
            <summary>下一个过滤器</summary>
        </member>
        <member name="M:NewLife.Data.FilterBase.Execute(NewLife.Data.FilterContext)">
            <summary>对封包执行过滤器</summary>
            <param name="context"></param>
        </member>
        <member name="M:NewLife.Data.FilterBase.OnExecute(NewLife.Data.FilterContext)">
            <summary>执行过滤</summary>
            <param name="context"></param>
            <returns>返回是否执行下一个过滤器</returns>
        </member>
        <member name="T:NewLife.Data.Packet">
            <summary>数据包</summary>
        </member>
        <member name="P:NewLife.Data.Packet.Data">
            <summary>数据</summary>
        </member>
        <member name="P:NewLife.Data.Packet.Offset">
            <summary>偏移</summary>
        </member>
        <member name="P:NewLife.Data.Packet.Count">
            <summary>长度</summary>
        </member>
        <member name="P:NewLife.Data.Packet.Next">
            <summary>下一个链式包</summary>
        </member>
        <member name="P:NewLife.Data.Packet.Total">
            <summary>总长度</summary>
        </member>
        <member name="M:NewLife.Data.Packet.#ctor(System.Byte[],System.Int32,System.Int32)">
            <summary>根据数据区实例化</summary>
            <param name="data"></param>
            <param name="offset"></param>
            <param name="count"></param>
        </member>
        <member name="M:NewLife.Data.Packet.#ctor(System.ArraySegment{System.Byte})">
            <summary>根据数组段实例化</summary>
            <param name="seg"></param>
        </member>
        <member name="M:NewLife.Data.Packet.#ctor(System.IO.Stream)">
            <summary>从可扩展内存流实例化，尝试窃取内存流内部的字节数组，失败后拷贝</summary>
            <remarks>因数据包内数组窃取自内存流，需要特别小心，避免多线程共用</remarks>
            <param name="stream"></param>
        </member>
        <member name="P:NewLife.Data.Packet.Item(System.Int32)">
            <summary>获取/设置 指定位置的字节</summary>
            <param name="index"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.Set(System.Byte[],System.Int32,System.Int32)">
            <summary>设置新的数据区</summary>
            <param name="data">数据区</param>
            <param name="offset">偏移</param>
            <param name="count">字节个数</param>
        </member>
        <member name="M:NewLife.Data.Packet.Slice(System.Int32,System.Int32)">
            <summary>截取子数据区</summary>
            <param name="offset">相对偏移</param>
            <param name="count">字节个数</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.IndexOf(System.Byte[],System.Int32,System.Int32)">
            <summary>查找目标数组</summary>
            <param name="data">目标数组</param>
            <param name="offset">本数组起始偏移</param>
            <param name="count">本数组搜索个数</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.Append(NewLife.Data.Packet)">
            <summary>附加一个包到当前包链的末尾</summary>
            <param name="pk"></param>
        </member>
        <member name="M:NewLife.Data.Packet.ToArray">
            <summary>返回字节数组。如果是完整数组直接返回，否则截取</summary>
            <remarks>不一定是全新数据，如果需要全新数据请克隆</remarks>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.ReadBytes(System.Int32,System.Int32)">
            <summary>从封包中读取指定数据</summary>
            <param name="offset"></param>
            <param name="count"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.ToSegment">
            <summary>返回数据段</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.ToSegments">
            <summary>返回数据段集合</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.GetStream">
            <summary>获取封包的数据流形式</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.CopyTo(System.IO.Stream)">
            <summary>把封包写入到数据流</summary>
            <param name="stream"></param>
        </member>
        <member name="M:NewLife.Data.Packet.WriteTo(System.Byte[],System.Int32,System.Int32)">
            <summary>把封包写入到目标数组</summary>
            <param name="buffer"></param>
            <param name="offset"></param>
            <param name="count"></param>
        </member>
        <member name="M:NewLife.Data.Packet.CopyToAsync(System.IO.Stream)">
            <summary>异步复制到目标数据流</summary>
            <param name="stream"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.Clone">
            <summary>深度克隆一份数据包，拷贝数据区</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.ToStr(System.Text.Encoding,System.Int32,System.Int32)">
            <summary>以字符串表示</summary>
            <param name="encoding">字符串编码，默认URF-8</param>
            <param name="offset"></param>
            <param name="count"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.ToHex(System.Int32,System.String,System.Int32)">
            <summary>以十六进制编码表示</summary>
            <param name="maxLength">最大显示多少个字节。默认-1显示全部</param>
            <param name="separate">分隔符</param>
            <param name="groupSize">分组大小，为0时对每个字节应用分隔符，否则对每个分组使用</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.op_Implicit(System.Byte[])~NewLife.Data.Packet">
            <summary>重载类型转换，字节数组直接转为Packet对象</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.op_Implicit(System.ArraySegment{System.Byte})~NewLife.Data.Packet">
            <summary>重载类型转换，一维数组直接转为Packet对象</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.Packet.ToString">
            <summary>已重载</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Data.PageParameter">
            <summary>分页参数信息</summary>
        </member>
        <member name="P:NewLife.Data.PageParameter.Sort">
            <summary>获取 或 设置 排序字段，前台接收，便于做安全性校验</summary>
        </member>
        <member name="P:NewLife.Data.PageParameter.Desc">
            <summary>获取 或 设置 是否降序</summary>
        </member>
        <member name="P:NewLife.Data.PageParameter.PageIndex">
            <summary>获取 或 设置 页面索引。从1开始，默认1</summary>
            <remarks>如果设定了开始行，分页时将不再使用PageIndex</remarks>
        </member>
        <member name="P:NewLife.Data.PageParameter.PageSize">
            <summary>获取 或 设置 页面大小。默认20，若为0表示不分页</summary>
        </member>
        <member name="P:NewLife.Data.PageParameter.TotalCount">
            <summary>获取 或 设置 总记录数</summary>
        </member>
        <member name="P:NewLife.Data.PageParameter.PageCount">
            <summary>获取 页数</summary>
        </member>
        <member name="P:NewLife.Data.PageParameter.OrderBy">
            <summary>获取 或 设置 组合起来的排序字句。如果没有设置则取Sort+Desc，后台设置，不经过安全性校验</summary>
        </member>
        <member name="P:NewLife.Data.PageParameter.StartRow">
            <summary>获取 或 设置 开始行</summary>
            <remarks>如果设定了开始行，分页时将不再使用PageIndex</remarks>
        </member>
        <member name="P:NewLife.Data.PageParameter.RetrieveTotalCount">
            <summary>获取 或 设置 是否获取总记录数，默认false</summary>
        </member>
        <member name="P:NewLife.Data.PageParameter.State">
            <summary>获取 或 设置 状态。用于传递统计等数据</summary>
        </member>
        <member name="P:NewLife.Data.PageParameter.RetrieveState">
            <summary>获取 或 设置 是否获取统计，默认false</summary>
        </member>
        <member name="M:NewLife.Data.PageParameter.#ctor">
            <summary>实例化分页参数</summary>
        </member>
        <member name="M:NewLife.Data.PageParameter.#ctor(NewLife.Data.PageParameter)">
            <summary>通过另一个分页参数来实例化当前分页参数</summary>
            <param name="pm"></param>
        </member>
        <member name="M:NewLife.Data.PageParameter.CopyFrom(NewLife.Data.PageParameter)">
            <summary>从另一个分页参数拷贝到当前分页参数</summary>
            <param name="pm"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Data.PageParameter.GetKey">
            <summary>获取表示分页参数唯一性的键值，可用作缓存键</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.EventArgs`1">
            <summary>泛型事件参数</summary>
            <typeparam name="TArg"></typeparam>
        </member>
        <member name="P:NewLife.EventArgs`1.Arg">
            <summary>参数</summary>
        </member>
        <member name="M:NewLife.EventArgs`1.#ctor(`0)">
            <summary>使用参数初始化</summary>
            <param name="arg"></param>
        </member>
        <member name="M:NewLife.EventArgs`1.Pop(`0@)">
            <summary>弹出</summary>
            <param name="arg"></param>
        </member>
        <member name="T:NewLife.EventArgs`2">
            <summary>泛型事件参数</summary>
            <typeparam name="TArg1"></typeparam>
            <typeparam name="TArg2"></typeparam>
        </member>
        <member name="P:NewLife.EventArgs`2.Arg1">
            <summary>参数</summary>
        </member>
        <member name="P:NewLife.EventArgs`2.Arg2">
            <summary>参数2</summary>
        </member>
        <member name="M:NewLife.EventArgs`2.#ctor(`0,`1)">
            <summary>使用参数初始化</summary>
            <param name="arg1"></param>
            <param name="arg2"></param>
        </member>
        <member name="M:NewLife.EventArgs`2.Pop(`0@,`1@)">
            <summary>弹出</summary>
            <param name="arg1"></param>
            <param name="arg2"></param>
        </member>
        <member name="T:NewLife.EventArgs`3">
            <summary>泛型事件参数</summary>
            <typeparam name="TArg1"></typeparam>
            <typeparam name="TArg2"></typeparam>
            <typeparam name="TArg3"></typeparam>
        </member>
        <member name="P:NewLife.EventArgs`3.Arg1">
            <summary>参数</summary>
        </member>
        <member name="P:NewLife.EventArgs`3.Arg2">
            <summary>参数2</summary>
        </member>
        <member name="P:NewLife.EventArgs`3.Arg3">
            <summary>参数3</summary>
        </member>
        <member name="M:NewLife.EventArgs`3.#ctor(`0,`1,`2)">
            <summary>使用参数初始化</summary>
            <param name="arg1"></param>
            <param name="arg2"></param>
            <param name="arg3"></param>
        </member>
        <member name="M:NewLife.EventArgs`3.Pop(`0@,`1@,`2@)">
            <summary>弹出</summary>
            <param name="arg1"></param>
            <param name="arg2"></param>
            <param name="arg3"></param>
        </member>
        <member name="T:NewLife.EventArgs`4">
            <summary>泛型事件参数</summary>
            <typeparam name="TArg1"></typeparam>
            <typeparam name="TArg2"></typeparam>
            <typeparam name="TArg3"></typeparam>
            <typeparam name="TArg4"></typeparam>
        </member>
        <member name="P:NewLife.EventArgs`4.Arg1">
            <summary>参数</summary>
        </member>
        <member name="P:NewLife.EventArgs`4.Arg2">
            <summary>参数2</summary>
        </member>
        <member name="P:NewLife.EventArgs`4.Arg3">
            <summary>参数3</summary>
        </member>
        <member name="P:NewLife.EventArgs`4.Arg4">
            <summary>参数4</summary>
        </member>
        <member name="M:NewLife.EventArgs`4.#ctor(`0,`1,`2,`3)">
            <summary>使用参数初始化</summary>
            <param name="arg1"></param>
            <param name="arg2"></param>
            <param name="arg3"></param>
            <param name="arg4"></param>
        </member>
        <member name="M:NewLife.EventArgs`4.Pop(`0@,`1@,`2@,`3@)">
            <summary>弹出</summary>
            <param name="arg1"></param>
            <param name="arg2"></param>
            <param name="arg3"></param>
            <param name="arg4"></param>
        </member>
        <member name="T:NewLife.WeakAction`1">
            <summary>弱引用Action</summary>
            <remarks>
            常见的事件和委托，都包括两部分：对象和方法，当然如果委托到静态方法上，对象是为空的。
            如果把事件委托到某个对象的方法上，同时就间接的引用了这个对象，导致其一直无法被回收，从而造成内存泄漏。
            弱引用Action，原理就是把委托拆分，然后弱引用对象部分，需要调用委托的时候，再把对象“拉”回来，如果被回收了，就没有必要再调用它的方法了。
            </remarks>
            <typeparam name="TArgs"></typeparam>
        </member>
        <member name="F:NewLife.WeakAction`1.Target">
            <summary>目标对象。弱引用，使得调用方对象可以被GC回收</summary>
        </member>
        <member name="F:NewLife.WeakAction`1.Method">
            <summary>委托方法</summary>
        </member>
        <member name="F:NewLife.WeakAction`1.Handler">
            <summary>经过包装的新的委托</summary>
        </member>
        <member name="F:NewLife.WeakAction`1.UnHandler">
            <summary>取消注册的委托</summary>
        </member>
        <member name="F:NewLife.WeakAction`1.Once">
            <summary>是否只使用一次，如果只使用一次，执行委托后马上取消注册</summary>
        </member>
        <member name="P:NewLife.WeakAction`1.IsAlive">
            <summary>是否可用</summary>
        </member>
        <member name="M:NewLife.WeakAction`1.#ctor(System.Object,System.Reflection.MethodInfo)">
            <summary>实例化</summary>
            <param name="target">目标对象</param>
            <param name="method">目标方法</param>
        </member>
        <member name="M:NewLife.WeakAction`1.#ctor(System.Object,System.Reflection.MethodInfo,System.Action{System.Action{`0}},System.Boolean)">
            <summary>实例化</summary>
            <param name="target">目标对象</param>
            <param name="method">目标方法</param>
            <param name="unHandler">取消注册回调</param>
            <param name="once">是否一次性事件</param>
        </member>
        <member name="M:NewLife.WeakAction`1.#ctor(System.Delegate)">
            <summary>实例化</summary>
            <param name="handler">事件处理器</param>
        </member>
        <member name="M:NewLife.WeakAction`1.#ctor(System.Delegate,System.Action{System.Action{`0}},System.Boolean)">
            <summary>使用事件处理器、取消注册回调、是否一次性事件来初始化</summary>
            <param name="handler">事件处理器</param>
            <param name="unHandler">取消注册回调</param>
            <param name="once">是否一次性事件</param>
        </member>
        <member name="M:NewLife.WeakAction`1.Invoke(`0)">
            <summary>调用委托</summary>
            <param name="e"></param>
        </member>
        <member name="M:NewLife.WeakAction`1.op_Implicit(NewLife.WeakAction{`0})~System.Action{`0}">
            <summary>把弱引用事件处理器转换为普通事件处理器</summary>
            <param name="handler"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.WeakAction`1.ToString">
            <summary>已重载</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.XException">
            <summary>X组件异常</summary>
        </member>
        <member name="M:NewLife.XException.#ctor">
            <summary>初始化</summary>
        </member>
        <member name="M:NewLife.XException.#ctor(System.String)">
            <summary>初始化</summary>
            <param name="message"></param>
        </member>
        <member name="M:NewLife.XException.#ctor(System.String,System.Object[])">
            <summary>初始化</summary>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="M:NewLife.XException.#ctor(System.String,System.Exception)">
            <summary>初始化</summary>
            <param name="message"></param>
            <param name="innerException"></param>
        </member>
        <member name="M:NewLife.XException.#ctor(System.Exception,System.String,System.Object[])">
            <summary>初始化</summary>
            <param name="innerException"></param>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="M:NewLife.XException.#ctor(System.Exception)">
            <summary>初始化</summary>
            <param name="innerException"></param>
        </member>
        <member name="T:NewLife.ExceptionEventArgs">
            <summary>异常事件参数</summary>
        </member>
        <member name="P:NewLife.ExceptionEventArgs.Action">
            <summary>发生异常时进行的动作</summary>
        </member>
        <member name="P:NewLife.ExceptionEventArgs.Exception">
            <summary>异常</summary>
        </member>
        <member name="T:NewLife.ExceptionHelper">
            <summary>异常助手</summary>
        </member>
        <member name="M:NewLife.ExceptionHelper.IsDisposed(System.Exception)">
            <summary>是否对象已被释放异常</summary>
            <param name="ex"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Expressions.MathExpression">
            <summary>数学表达式</summary>
        </member>
        <member name="F:NewLife.Expressions.MathExpression.AddChar">
            <summary>加法</summary>
        </member>
        <member name="F:NewLife.Expressions.MathExpression.SubtractChar">
            <summary>减法</summary>
        </member>
        <member name="F:NewLife.Expressions.MathExpression.MultiplyChar">
            <summary>乘法</summary>
        </member>
        <member name="F:NewLife.Expressions.MathExpression.DivideChar">
            <summary>除法</summary>
        </member>
        <member name="M:NewLife.Expressions.MathExpression.#ctor">
            <summary>实例化</summary>
        </member>
        <member name="M:NewLife.Expressions.MathExpression.GetOperationLevel(System.String)">
            <summary>计算运算符优先级</summary>
            <param name="op"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Expressions.MathExpression.AdapteAndReplace(System.String)">
            <summary>适配和替换</summary>
            <param name="expression"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Expressions.MathExpression.Complie(System.String,System.Object[])">
            <summary>解逆波兰表达式</summary>
            <param name="expression">标准逆波兰表达式</param>
            <param name="args"></param>
            <returns>逆波兰表达式的解</returns>
        </member>
        <member name="M:NewLife.Expressions.MathExpression.IsValid(System.String[])">
            <summary>是否有效</summary>
            <param name="arr"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Expressions.MathExpression.ToDouble(System.String)">
            <summary>转为浮点数</summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Expressions.MathExpression.ComplieRpnExp(System.Double,System.Double,System.String)">
            <summary>
            计算逆波兰表达式
            </summary>
            <param name="last">最后压入数字堆栈的数字</param>
            <param name="first">首先压入数字堆栈的数字</param>
            <param name="op">操作运算符</param>
            <returns>返回计算结果</returns>
        </member>
        <member name="T:NewLife.Expressions.RpnExpression">
            <summary>逆波兰表达式</summary>
        </member>
        <member name="F:NewLife.Expressions.RpnExpression.LeftBracket">
            <summary>左括号</summary>
        </member>
        <member name="F:NewLife.Expressions.RpnExpression.RightBracket">
            <summary>右括号</summary>
        </member>
        <member name="F:NewLife.Expressions.RpnExpression.JoinChar">
            <summary>连接符</summary>
        </member>
        <member name="F:NewLife.Expressions.RpnExpression.EmptyChar">
            <summary>空格</summary>
        </member>
        <member name="P:NewLife.Expressions.RpnExpression.OperationChars">
            <summary>操作符数组</summary>
        </member>
        <member name="M:NewLife.Expressions.RpnExpression.IsBracket(System.String)">
            <summary>是否括号</summary>
            <param name="ch"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Expressions.RpnExpression.IsBracket(System.Char)">
            <summary>是否括号</summary>
            <param name="ch"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Expressions.RpnExpression.GetOperationLevel(System.String)">
            <summary>计算操作等级</summary>
            <param name="op"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Expressions.RpnExpression.IsBracketMatch(System.String)">
            <summary>是否括号匹配</summary>
            <param name="expression"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Expressions.RpnExpression.AdapteAndReplace(System.String)">
            <summary>适配器和替换</summary>
            <param name="expression"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Expressions.RpnExpression.Value">
            <summary>值</summary>
        </member>
        <member name="M:NewLife.Expressions.RpnExpression.ToExpression(System.String)">
            <summary>将中缀表达式转换为逆波兰表达式</summary>
            <param name="expression">标准中缀表达式</param>
            <returns>标准逆波兰表达式</returns>
        </member>
        <member name="M:NewLife.Expressions.RpnExpression.IsValid(System.String[])">
            <summary>是否有效</summary>
            <param name="splitArray"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Expressions.RpnExpression.Complie(System.String,System.Object[])">
            <summary>编译计算</summary>
            <param name="expression"></param>
            <param name="args"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Expressions.UnionExpresion">
            <summary>与或非表达式</summary>
        </member>
        <member name="F:NewLife.Expressions.UnionExpresion.AndChar">
            <summary>位与</summary>
        </member>
        <member name="F:NewLife.Expressions.UnionExpresion.OrChar">
            <summary>位或</summary>
        </member>
        <member name="M:NewLife.Expressions.UnionExpresion.#ctor">
            <summary>实例化</summary>
        </member>
        <member name="M:NewLife.Expressions.UnionExpresion.GetOperationLevel(System.String)">
            <summary>操作符等级</summary>
            <param name="op"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Expressions.UnionExpresion.AdapteAndReplace(System.String)">
            <summary>适配替换</summary>
            <param name="expression"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Expressions.UnionExpresion.Container">
            <summary>容器</summary>
        </member>
        <member name="M:NewLife.Expressions.UnionExpresion.Complie(System.String,System.Object[])">
            <summary>解逆波兰表达式</summary>
            <param name="expression">标准逆波兰表达式</param>
            <param name="args"></param>
            <returns>逆波兰表达式的解</returns>
        </member>
        <member name="M:NewLife.Expressions.UnionExpresion.IsValid(System.String[])">
            <summary>是否有效</summary>
            <param name="arr"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Expressions.UnionExpresion.GetAllMarks">
            <summary>所有掩码</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Extension.SpeakProvider.SpeakAsyncCancelAll">
            <summary>
            停止话音播报
            </summary>
        </member>
        <member name="T:NewLife.Http.HttpBase">
            <summary>Http请求响应基类</summary>
        </member>
        <member name="P:NewLife.Http.HttpBase.ContentLength">
            <summary>内容长度</summary>
        </member>
        <member name="P:NewLife.Http.HttpBase.ContentType">
            <summary>内容类型</summary>
        </member>
        <member name="P:NewLife.Http.HttpBase.Headers">
            <summary>头部集合</summary>
        </member>
        <member name="P:NewLife.Http.HttpBase.Item(System.String)">
            <summary>获取/设置 头部</summary>
            <param name="key"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Http.HttpBase.Expire">
            <summary>过期时间</summary>
        </member>
        <member name="P:NewLife.Http.HttpBase.IsCompleted">
            <summary>是否已完整</summary>
        </member>
        <member name="P:NewLife.Http.HttpBase.BodyLength">
            <summary>主体长度</summary>
        </member>
        <member name="M:NewLife.Http.HttpBase.OnParse(System.String)">
            <summary>分析第一行</summary>
            <param name="firstLine"></param>
        </member>
        <member name="M:NewLife.Http.HttpBase.Build(NewLife.Data.Packet)">
            <summary>创建请求响应包</summary>
            <param name="data"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpBase.BuildHeader(System.Int32)">
            <summary>创建头部</summary>
            <param name="length"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Http.HttpCodec">
            <summary>Http编解码器</summary>
        </member>
        <member name="M:NewLife.Http.HttpCodec.Write(NewLife.Model.IHandlerContext,System.Object)">
            <summary>写入数据</summary>
            <param name="context"></param>
            <param name="message"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpCodec.Read(NewLife.Model.IHandlerContext,System.Object)">
            <summary>读取数据</summary>
            <param name="context"></param>
            <param name="message"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Http.HttpMessage">
            <summary>Http消息</summary>
        </member>
        <member name="P:NewLife.Http.HttpMessage.Reply">
            <summary>是否响应</summary>
        </member>
        <member name="P:NewLife.Http.HttpMessage.Error">
            <summary>是否有错</summary>
        </member>
        <member name="P:NewLife.Http.HttpMessage.OneWay">
            <summary>单向请求</summary>
        </member>
        <member name="P:NewLife.Http.HttpMessage.Header">
            <summary>头部数据</summary>
        </member>
        <member name="P:NewLife.Http.HttpMessage.Payload">
            <summary>负载数据</summary>
        </member>
        <member name="M:NewLife.Http.HttpMessage.CreateReply">
            <summary>根据请求创建配对的响应消息</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpMessage.Read(NewLife.Data.Packet)">
            <summary>从数据包中读取消息</summary>
            <param name="pk"></param>
            <returns>是否成功</returns>
        </member>
        <member name="M:NewLife.Http.HttpMessage.ToPacket">
            <summary>把消息转为封包</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Http.HttpEncoder">
            <summary>Http编码器</summary>
        </member>
        <member name="M:NewLife.Http.HttpEncoder.Encode(System.String,System.Int32,System.Object)">
            <summary>编码</summary>
            <param name="action"></param>
            <param name="code"></param>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpEncoder.DecodeParameters(System.String,NewLife.Data.Packet)">
            <summary>解码参数</summary>
            <param name="action"></param>
            <param name="data"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpEncoder.DecodeResult(System.String,NewLife.Data.Packet)">
            <summary>解码结果</summary>
            <param name="action"></param>
            <param name="data"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpEncoder.Convert(System.Object,System.Type)">
            <summary>转换为目标类型</summary>
            <param name="obj"></param>
            <param name="targetType"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpEncoder.CreateRequest(System.String,System.Object)">
            <summary>创建请求</summary>
            <param name="action"></param>
            <param name="args"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpEncoder.CreateResponse(NewLife.Messaging.IMessage,System.String,System.Int32,System.Object)">
            <summary>创建响应</summary>
            <param name="msg"></param>
            <param name="action"></param>
            <param name="code"></param>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpEncoder.Decode(NewLife.Messaging.IMessage,System.String@,System.Int32@,NewLife.Data.Packet@)">
            <summary>解码 请求/响应</summary>
            <param name="msg">消息</param>
            <param name="action">服务动作</param>
            <param name="code">错误码</param>
            <param name="value">参数或结果</param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Http.HttpHelper">
            <summary>Http帮助类</summary>
        </member>
        <member name="M:NewLife.Http.HttpHelper.MakeRequest(System.String,System.Uri,System.Collections.Generic.IDictionary{System.String,System.Object},NewLife.Data.Packet)">
            <summary>创建请求包</summary>
            <param name="method"></param>
            <param name="uri"></param>
            <param name="headers"></param>
            <param name="pk"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpHelper.MakeResponse(System.Net.HttpStatusCode,System.Collections.Generic.IDictionary{System.String,System.Object},NewLife.Data.Packet)">
            <summary>创建响应包</summary>
            <param name="code"></param>
            <param name="headers"></param>
            <param name="pk"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpHelper.ParseHeader(NewLife.Data.Packet)">
            <summary>分析头部</summary>
            <param name="pk"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpHelper.MakeHandshake(NewLife.Http.HttpRequest)">
            <summary>建立握手包</summary>
            <param name="request"></param>
        </member>
        <member name="M:NewLife.Http.HttpHelper.Handshake(System.String,NewLife.Http.HttpResponse)">
            <summary>握手</summary>
            <param name="key"></param>
            <param name="response"></param>
        </member>
        <member name="M:NewLife.Http.HttpHelper.ParseWS(NewLife.Data.Packet)">
            <summary>分析WS数据包</summary>
            <param name="pk"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpHelper.MakeWS(NewLife.Data.Packet)">
            <summary>创建WS请求包</summary>
            <param name="pk"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Http.HttpRequest">
            <summary>Http请求</summary>
        </member>
        <member name="P:NewLife.Http.HttpRequest.Method">
            <summary>Http方法</summary>
        </member>
        <member name="P:NewLife.Http.HttpRequest.Url">
            <summary>资源路径</summary>
        </member>
        <member name="P:NewLife.Http.HttpRequest.UserAgent">
            <summary>用户代理</summary>
        </member>
        <member name="P:NewLife.Http.HttpRequest.Compressed">
            <summary>是否压缩</summary>
        </member>
        <member name="P:NewLife.Http.HttpRequest.KeepAlive">
            <summary>保持连接</summary>
        </member>
        <member name="P:NewLife.Http.HttpRequest.Accept">
            <summary>可接受内容</summary>
        </member>
        <member name="P:NewLife.Http.HttpRequest.AcceptLanguage">
            <summary>接受语言</summary>
        </member>
        <member name="P:NewLife.Http.HttpRequest.Referer">
            <summary>引用路径</summary>
        </member>
        <member name="M:NewLife.Http.HttpRequest.OnParse(System.String)">
            <summary>分析第一行</summary>
            <param name="firstLine"></param>
        </member>
        <member name="M:NewLife.Http.HttpRequest.BuildHeader(System.Int32)">
            <summary>创建头部</summary>
            <param name="length"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Http.HttpResponse">
            <summary>Http响应</summary>
        </member>
        <member name="P:NewLife.Http.HttpResponse.IsSSL">
            <summary>是否启用SSL</summary>
        </member>
        <member name="P:NewLife.Http.HttpResponse.StatusCode">
            <summary>状态码</summary>
        </member>
        <member name="P:NewLife.Http.HttpResponse.StatusDescription">
            <summary>状态描述</summary>
        </member>
        <member name="M:NewLife.Http.HttpResponse.OnParse(System.String)">
            <summary>分析第一行</summary>
            <param name="firstLine"></param>
        </member>
        <member name="M:NewLife.Http.HttpResponse.BuildHeader(System.Int32)">
            <summary>创建头部</summary>
            <param name="length"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.HttpResponse.Valid">
            <summary>验证，如果失败则抛出异常</summary>
        </member>
        <member name="T:NewLife.Http.HttpServer">
            <summary>Http服务器</summary>
        </member>
        <member name="M:NewLife.Http.HttpServer.#ctor">
            <summary>实例化</summary>
        </member>
        <member name="T:NewLife.Http.TinyHttpClient">
            <summary>迷你Http客户端。不支持https和302跳转</summary>
        </member>
        <member name="P:NewLife.Http.TinyHttpClient.Client">
            <summary>客户端</summary>
        </member>
        <member name="P:NewLife.Http.TinyHttpClient.ContentType">
            <summary>内容类型</summary>
        </member>
        <member name="P:NewLife.Http.TinyHttpClient.ContentLength">
            <summary>内容长度</summary>
        </member>
        <member name="P:NewLife.Http.TinyHttpClient.KeepAlive">
            <summary>保持连接</summary>
        </member>
        <member name="P:NewLife.Http.TinyHttpClient.StatusCode">
            <summary>状态码</summary>
        </member>
        <member name="P:NewLife.Http.TinyHttpClient.Timeout">
            <summary>超时时间。默认15s</summary>
        </member>
        <member name="P:NewLife.Http.TinyHttpClient.Headers">
            <summary>头部集合</summary>
        </member>
        <member name="M:NewLife.Http.TinyHttpClient.OnDispose(System.Boolean)">
            <summary>销毁</summary>
            <param name="disposing"></param>
        </member>
        <member name="M:NewLife.Http.TinyHttpClient.SendDataAsync(System.Uri,NewLife.Data.Packet)">
            <summary>异步请求</summary>
            <param name="uri"></param>
            <param name="request"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.TinyHttpClient.SendAsync(System.Uri,System.Byte[])">
            <summary>异步发出请求，并接收响应</summary>
            <param name="uri"></param>
            <param name="data"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.TinyHttpClient.SendData(System.Uri,NewLife.Data.Packet)">
            <summary>同步请求</summary>
            <param name="uri"></param>
            <param name="request"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.TinyHttpClient.Send(System.Uri,System.Byte[])">
            <summary>异步发出请求，并接收响应</summary>
            <param name="uri"></param>
            <param name="data"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.TinyHttpClient.BuildRequest(System.Uri,System.Byte[])">
            <summary>构造请求头</summary>
            <param name="uri"></param>
            <param name="data"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.TinyHttpClient.ParseResponse(NewLife.Data.Packet)">
            <summary>解析响应</summary>
            <param name="rs"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.TinyHttpClient.GetPool(System.String)">
            <summary>根据主机获取对象池</summary>
            <param name="host"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.TinyHttpClient.GetStringAsync(System.String)">
            <summary>异步获取</summary>
            <param name="url">地址</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Http.TinyHttpClient.GetString(System.String)">
            <summary>同步获取</summary>
            <param name="url"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.IO.CsvFile">
            <summary>Csv文件</summary>
            <remarks>
            支持整体读写以及增量式读写，目标是读写超大Csv文件
            </remarks>
        </member>
        <member name="P:NewLife.IO.CsvFile.Encoding">
            <summary>文件编码</summary>
        </member>
        <member name="P:NewLife.IO.CsvFile.Separator">
            <summary>分隔符。默认逗号</summary>
        </member>
        <member name="M:NewLife.IO.CsvFile.#ctor(System.IO.Stream)">
            <summary>数据流实例化</summary>
            <param name="stream"></param>
        </member>
        <member name="M:NewLife.IO.CsvFile.#ctor(System.String,System.Boolean)">
            <summary>Csv文件实例化</summary>
            <param name="file"></param>
            <param name="write"></param>
        </member>
        <member name="M:NewLife.IO.CsvFile.OnDispose(System.Boolean)">
            <summary>销毁</summary>
            <param name="disposing"></param>
        </member>
        <member name="M:NewLife.IO.CsvFile.ReadLine">
            <summary>读取一行</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.IO.CsvFile.ReadAll">
            <summary>读取所有行</summary>
            <returns></returns>
        </member>
        <member name="M:NewLife.IO.CsvFile.WriteAll(System.Collections.Generic.IEnumerable{System.Collections.Generic.IEnumerable{System.Object}})">
            <summary>写入全部</summary>
            <param name="data"></param>
        </member>
        <member name="M:NewLife.IO.CsvFile.WriteLine(System.Collections.Generic.IEnumerable{System.Object})">
            <summary>写入一行</summary>
            <param name="line"></param>
        </member>
        <member name="T:NewLife.IO.EncodingHelper">
            <summary>编码助手</summary>
        </member>
        <member name="M:NewLife.IO.EncodingHelper.Detect(System.String)">
            <summary>检测文件编码</summary>
            <param name="filename">文件名</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.IO.EncodingHelper.DetectEncoding(System.IO.FileInfo)">
            <summary>检测文件编码</summary>
            <param name="file"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.IO.EncodingHelper.Detect(System.IO.Stream,System.Int64)">
            <summary>检测数据流编码</summary>
            <param name="stream">数据流</param>
            <param name="sampleSize">BOM检测失败时用于启发式探索的数据大小</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.IO.EncodingHelper.Detect(System.Byte[])">
            <summary>检测字节数组编码</summary>
            <param name="data">字节数组</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.IO.EncodingHelper.DetectBOM(System.Byte[])">
            <summary>检测BOM字节序</summary>
            <param name="boms"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.IO.EncodingHelper.DetectASCII(System.Byte[])">
            <summary>检测是否ASCII</summary>
            <param name="data"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.IO.EncodingHelper.DetectUnicode(System.Byte[])">
            <summary>启发式探测Unicode编码</summary>
            <param name="data"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.IO.EncodingHelper.IsCommonASCII(System.Byte)">
            <summary>是否可见ASCII</summary>
            <param name="bt"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.IO.EncodingHelper.DetectSuspiciousUTF8SequenceLength(System.Byte[],System.Int64)">
            <summary>检测可能的UTF8序列长度</summary>
            <param name="buf"></param>
            <param name="pos"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.IO.FileSource">
            <summary>文件资源</summary>
        </member>
        <member name="M:NewLife.IO.FileSource.ReleaseFile(System.Reflection.Assembly,System.String,System.String,System.Boolean)">
            <summary>释放文件</summary>
            <param name="asm"></param>
            <param name="fileName"></param>
            <param name="destFile"></param>
            <param name="overWrite"></param>
        </member>
        <member name="M:NewLife.IO.FileSource.ReleaseFolder(System.Reflection.Assembly,System.String,System.String,System.Boolean)">
            <summary>释放文件夹</summary>
            <param name="asm"></param>
            <param name="prefix"></param>
            <param name="dest"></param>
            <param name="overWrite"></param>
        </member>
        <member name="M:NewLife.IO.FileSource.ReleaseFolder(System.Reflection.Assembly,System.String,System.String,System.Boolean,System.Func{System.String,System.String})">
            <summary>释放文件夹</summary>
            <param name="asm"></param>
            <param name="prefix"></param>
            <param name="dest"></param>
            <param name="overWrite"></param>
            <param name="filenameResolver"></param>
        </member>
        <member name="M:NewLife.IO.FileSource.GetFileResource(System.Reflection.Assembly,System.String)">
            <summary>获取文件资源</summary>
            <param name="asm"></param>
            <param name="filename"></param>
            <returns></returns>
        </member>
        <member name="T:NewLife.Json.JsonConfig`1">
            <summary>Json配置文件基类</summary>
            <remarks>
            标准用法：TConfig.Current
            
            配置实体类通过<see cref="T:NewLife.Json.JsonConfigFileAttribute"/>特性指定配置文件路径以及自动更新时间。
            Current将加载配置文件，如果文件不存在或者加载失败，将实例化一个对象返回。
            
            考虑到自动刷新，不提供LoadFile和SaveFile等方法，可通过扩展方法ToXmlFileEntity和ToXmlFile实现。
            
            用户也可以通过配置实体类的静态构造函数修改基类的<see cref="P:NewLife.Json.JsonConfig`1._.ConfigFile"/>和<see cref="P:NewLife.Json.JsonConfig`1._.ReloadTime"/>来动态配置加载信息。
            </remarks>
            <typeparam name="TConfig"></typeparam>
        </member>
        <member name="P:NewLife.Json.JsonConfig`1.Current">
            <summary>当前实例。通过置空可以使其重新加载。</summary>
        </member>
        <member name="T:NewLife.Json.JsonConfig`1._">
            <summary>一些设置。派生类可以在自己的静态构造函数中指定</summary>
        </member>
        <member name="P:NewLife.Json.JsonConfig`1._.Debug">
            <summary>是否调试</summary>
        </member>
        <member name="P:NewLife.Json.JsonConfig`1._.ConfigFile">
            <summary>配置文件路径</summary>
        </member>
        <member name="P:NewLife.Json.JsonConfig`1._.ReloadTime">
            <summary>重新加载时间。单位：毫秒</summary>
        </member>
        <member name="P:NewLife.Json.JsonConfig`1._.SaveNew">
            <summary>没有配置文件时是否保存新配置。默认true</summary>
        </member>
        <member name="P:NewLife.Json.JsonConfig`1.ConfigFile">
            <summary>配置文件</summary>
        </member>
        <member name="F:NewLife.Json.JsonConfig`1.lastWrite">
            <summary>最后写入时间</summary>
        </member>
        <member name="F:NewLife.Json.JsonConfig`1.expire">
            <summary>过期时间。如果在这个时间之后再次访问，将检查文件修改时间</summary>
        </member>
        <member name="P:NewLife.Json.JsonConfig`1.IsUpdated">
            <summary>是否已更新。通过文件写入时间判断</summary>
        </member>
        <member name="M:NewLife.Json.JsonConfig`1.SetExpire">
            <summary>设置过期重新加载配置的时间</summary>
        </member>
        <member name="P:NewLife.Json.JsonConfig`1.IsNew">
            <summary>是否新的配置文件</summary>
        </member>
        <member name="M:NewLife.Json.JsonConfig`1.OnDispose(System.Boolean)">
            <summary>销毁</summary>
            <param name="disposing"></param>
        </member>
        <member name="M:NewLife.Json.JsonConfig`1.Load(System.String)">
            <summary>加载指定配置文件</summary>
            <param name="filename"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Json.JsonConfig`1.OnLoaded">
            <summary>从配置文件中读取完成后触发</summary>
        </member>
        <member name="M:NewLife.Json.JsonConfig`1.Save(System.String)">
            <summary>保存到配置文件中去</summary>
            <param name="filename"></param>
        </member>
        <member name="M:NewLife.Json.JsonConfig`1.Save">
            <summary>保存到配置文件中去</summary>
        </member>
        <member name="M:NewLife.Json.JsonConfig`1.SaveAsync">
            <summary>异步保存</summary>
        </member>
        <member name="M:NewLife.Json.JsonConfig`1.OnNew">
            <summary>新创建配置文件时执行</summary>
        </member>
        <member name="T:NewLife.Json.JsonConfigFileAttribute">
            <summary>Json配置文件特性</summary>
        </member>
        <member name="P:NewLife.Json.JsonConfigFileAttribute.FileName">
            <summary>配置文件名</summary>
        </member>
        <member name="P:NewLife.Json.JsonConfigFileAttribute.ReloadTime">
            <summary>重新加载时间。单位：毫秒</summary>
        </member>
        <member name="M:NewLife.Json.JsonConfigFileAttribute.#ctor(System.String)">
            <summary>指定配置文件名</summary>
            <param name="fileName"></param>
        </member>
        <member name="M:NewLife.Json.JsonConfigFileAttribute.#ctor(System.String,System.Int32)">
            <summary>指定配置文件名和重新加载时间（毫秒）</summary>
            <param name="fileName"></param>
            <param name="reloadTime"></param>
        </member>
        <member name="T:NewLife.Log.ActionLog">
            <summary>依托于动作的日志类</summary>
        </member>
        <member name="P:NewLife.Log.ActionLog.Method">
            <summary>方法</summary>
        </member>
        <member name="M:NewLife.Log.ActionLog.#ctor(System.Action{System.String,System.Object[]})">
            <summary>使用指定方法否则动作日志</summary>
            <param name="action"></param>
        </member>
        <member name="M:NewLife.Log.ActionLog.OnWrite(NewLife.Log.LogLevel,System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="level"></param>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="M:NewLife.Log.ActionLog.ToString">
            <summary>已重载</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Log.CodeTimer">
            <summary>代码性能计时器</summary>
            <remarks>参考了老赵（http://www.cnblogs.com/jeffreyzhao/archive/2009/03/10/codetimer.html）和eaglet（http://www.cnblogs.com/eaglet/archive/2009/03/10/1407791.html）两位的作品</remarks>
            <remarks>为了保证性能比较的公平性，采用了多种指标，并使用计时器重写等手段来避免各种不必要的损耗</remarks>
        </member>
        <member name="M:NewLife.Log.CodeTimer.Time(System.Int32,System.Action{System.Int32},System.Boolean)">
            <summary>计时</summary>
            <param name="times">次数</param>
            <param name="action">需要计时的委托</param>
            <param name="needTimeOne">是否需要预热</param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Log.CodeTimer.TimeLine(System.String,System.Int32,System.Action{System.Int32},System.Boolean)">
            <summary>计时，并用控制台输出行</summary>
            <param name="title">标题</param>
            <param name="times">次数</param>
            <param name="action">需要计时的委托</param>
            <param name="needTimeOne">是否需要预热</param>
        </member>
        <member name="M:NewLife.Log.CodeTimer.ShowHeader(System.String)">
            <summary>显示头部</summary>
            <param name="title"></param>
        </member>
        <member name="P:NewLife.Log.CodeTimer.Times">
            <summary>次数</summary>
        </member>
        <member name="P:NewLife.Log.CodeTimer.Action">
            <summary>迭代方法，如不指定，则使用Time(int index)</summary>
        </member>
        <member name="P:NewLife.Log.CodeTimer.ShowProgress">
            <summary>是否显示控制台进度</summary>
        </member>
        <member name="P:NewLife.Log.CodeTimer.Index">
            <summary>进度</summary>
        </member>
        <member name="P:NewLife.Log.CodeTimer.CpuCycles">
            <summary>CPU周期</summary>
        </member>
        <member name="P:NewLife.Log.CodeTimer.ThreadTime">
            <summary>线程时间，单位是ms</summary>
        </member>
        <member name="P:NewLife.Log.CodeTimer.Gen">
            <summary>GC代数</summary>
        </member>
        <member name="P:NewLife.Log.CodeTimer.Elapsed">
            <summary>执行时间</summary>
        </member>
        <member name="M:NewLife.Log.CodeTimer.#ctor">
            <summary>实例化一个代码计时器</summary>
        </member>
        <member name="M:NewLife.Log.CodeTimer.Time">
            <summary>计时核心方法，处理进程和线程优先级</summary>
        </member>
        <member name="M:NewLife.Log.CodeTimer.TimeTrue">
            <summary>真正的计时</summary>
        </member>
        <member name="M:NewLife.Log.CodeTimer.TimeOne">
            <summary>执行一次迭代，预热所有方法</summary>
        </member>
        <member name="M:NewLife.Log.CodeTimer.Init">
            <summary>迭代前执行，计算时间</summary>
        </member>
        <member name="M:NewLife.Log.CodeTimer.Time(System.Int32)">
            <summary>每一次迭代，计算时间</summary>
            <param name="index"></param>
        </member>
        <member name="M:NewLife.Log.CodeTimer.Finish">
            <summary>迭代后执行，计算时间</summary>
        </member>
        <member name="F:NewLife.Log.CodeTimer.msBase">
            <summary>基准时间</summary>
        </member>
        <member name="M:NewLife.Log.CodeTimer.ToString">
            <summary>已重载。输出依次分别是：执行时间、CPU线程时间、时钟周期、GC代数</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Log.CompositeLog">
            <summary>复合日志提供者，多种方式输出</summary>
        </member>
        <member name="P:NewLife.Log.CompositeLog.Logs">
            <summary>日志提供者集合</summary>
        </member>
        <member name="M:NewLife.Log.CompositeLog.#ctor">
            <summary>实例化</summary>
        </member>
        <member name="M:NewLife.Log.CompositeLog.#ctor(NewLife.Log.ILog)">
            <summary>实例化</summary>
            <param name="log"></param>
        </member>
        <member name="M:NewLife.Log.CompositeLog.#ctor(NewLife.Log.ILog,NewLife.Log.ILog)">
            <summary>实例化</summary>
            <param name="log1"></param>
            <param name="log2"></param>
        </member>
        <member name="M:NewLife.Log.CompositeLog.Add(NewLife.Log.ILog)">
            <summary>添加一个日志提供者</summary>
            <param name="log"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Log.CompositeLog.Remove(NewLife.Log.ILog)">
            <summary>删除日志提供者</summary>
            <param name="log"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Log.CompositeLog.OnWrite(NewLife.Log.LogLevel,System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="level"></param>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="M:NewLife.Log.CompositeLog.Get``1">
            <summary>从复合日志提供者中提取指定类型的日志提供者</summary>
            <typeparam name="TLog"></typeparam>
            <returns></returns>
        </member>
        <member name="M:NewLife.Log.CompositeLog.ToString">
            <summary>已重载。</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Log.ConsoleLog">
            <summary>控制台输出日志</summary>
        </member>
        <member name="P:NewLife.Log.ConsoleLog.UseColor">
            <summary>是否使用多种颜色，默认使用</summary>
        </member>
        <member name="M:NewLife.Log.ConsoleLog.OnWrite(NewLife.Log.LogLevel,System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="level"></param>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="M:NewLife.Log.ConsoleLog.ToString">
            <summary>已重载。</summary>
            <returns></returns>
        </member>
        <member name="T:NewLife.Log.ICounter">
            <summary>性能计数器接口</summary>
        </member>
        <member name="P:NewLife.Log.ICounter.Value">
            <summary>数值</summary>
        </member>
        <member name="P:NewLife.Log.ICounter.Times">
            <summary>次数</summary>
        </member>
        <member name="P:NewLife.Log.ICounter.Speed">
            <summary>速度</summary>
        </member>
        <member name="P:NewLife.Log.ICounter.Cost">
            <summary>平均耗时，单位us</summary>
        </member>
        <member name="M:NewLife.Log.ICounter.Increment(System.Int64,System.Int64)">
            <summary>增加</summary>
            <param name="value">增加的数量</param>
            <param name="usCost">耗时，单位us</param>
        </member>
        <member name="T:NewLife.Log.CounterHelper">
            <summary>计数器助手</summary>
        </member>
        <member name="M:NewLife.Log.CounterHelper.StartCount(NewLife.Log.ICounter)">
            <summary>开始计时</summary>
            <param name="counter"></param>
            <returns></returns>
        </member>
        <member name="M:NewLife.Log.CounterHelper.StopCount(NewLife.Log.ICounter,System.Nullable{System.Int64})">
            <summary>结束计时</summary>
            <param name="counter"></param>
            <param name="startTicks"></param>
        </member>
        <member name="T:NewLife.Log.ILog">
            <summary>日志接口</summary>
        </member>
        <member name="M:NewLife.Log.ILog.Write(NewLife.Log.LogLevel,System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="level">日志级别</param>
            <param name="format">格式化字符串</param>
            <param name="args">格式化参数</param>
        </member>
        <member name="M:NewLife.Log.ILog.Debug(System.String,System.Object[])">
            <summary>调试日志</summary>
            <param name="format">格式化字符串</param>
            <param name="args">格式化参数</param>
        </member>
        <member name="M:NewLife.Log.ILog.Info(System.String,System.Object[])">
            <summary>信息日志</summary>
            <param name="format">格式化字符串</param>
            <param name="args">格式化参数</param>
        </member>
        <member name="M:NewLife.Log.ILog.Warn(System.String,System.Object[])">
            <summary>警告日志</summary>
            <param name="format">格式化字符串</param>
            <param name="args">格式化参数</param>
        </member>
        <member name="M:NewLife.Log.ILog.Error(System.String,System.Object[])">
            <summary>错误日志</summary>
            <param name="format">格式化字符串</param>
            <param name="args">格式化参数</param>
        </member>
        <member name="M:NewLife.Log.ILog.Fatal(System.String,System.Object[])">
            <summary>严重错误日志</summary>
            <param name="format">格式化字符串</param>
            <param name="args">格式化参数</param>
        </member>
        <member name="P:NewLife.Log.ILog.Enable">
            <summary>是否启用日志</summary>
        </member>
        <member name="P:NewLife.Log.ILog.Level">
            <summary>日志等级，只输出大于等于该级别的日志，默认Info，打开NewLife.Debug时默认为最低的Debug</summary>
        </member>
        <member name="T:NewLife.Log.Logger">
            <summary>日志基类。提供日志的基本实现</summary>
        </member>
        <member name="M:NewLife.Log.Logger.Debug(System.String,System.Object[])">
            <summary>调试日志</summary>
            <param name="format">格式化字符串</param>
            <param name="args">格式化参数</param>
        </member>
        <member name="M:NewLife.Log.Logger.Info(System.String,System.Object[])">
            <summary>信息日志</summary>
            <param name="format">格式化字符串</param>
            <param name="args">格式化参数</param>
        </member>
        <member name="M:NewLife.Log.Logger.Warn(System.String,System.Object[])">
            <summary>警告日志</summary>
            <param name="format">格式化字符串</param>
            <param name="args">格式化参数</param>
        </member>
        <member name="M:NewLife.Log.Logger.Error(System.String,System.Object[])">
            <summary>错误日志</summary>
            <param name="format">格式化字符串</param>
            <param name="args">格式化参数</param>
        </member>
        <member name="M:NewLife.Log.Logger.Fatal(System.String,System.Object[])">
            <summary>严重错误日志</summary>
            <param name="format">格式化字符串</param>
            <param name="args">格式化参数</param>
        </member>
        <member name="M:NewLife.Log.Logger.Write(NewLife.Log.LogLevel,System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="level"></param>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="M:NewLife.Log.Logger.OnWrite(NewLife.Log.LogLevel,System.String,System.Object[])">
            <summary>写日志</summary>
            <param name="level"></param>
            <param name="format"></param>
            <param name="args"></param>
        </member>
        <member name="M:NewLife.Log.Logger.Format(System.String,System.Object[])">
            <summary>格式化参数，特殊处理异常和时间</summary>
            <param name="format"></param>
            <param name="args"></param>
            <returns></returns>
        </member>
        <member name="P:NewLife.Log.Logger.Enable">
            <summary>是否启用日志。默认true</summary>
        </member>
        <member name="P:NewLife.Log.Logger.Level">
            <summary>日志等级，只输出大于等于该级别的日志，默认Info，打开NewLife.Debug时默认为最低的Debug</summary>
        </member>
        <member name="P:NewLife.Log.Logger.Null">
            <summary>空日志实现</summary>
        </member>
        <member name="M:NewLife.Log.Logger.GetHead">
            <summary>输出日志头，包含所有环境信息</summary>
        </member>
        <member name="T:NewLife.Log.LogLevel">
            <summary>日志等级</summary>
        </member>
        <member name="F:NewLife.Log.LogLevel.All">
            <summary>打开所有日志记录</summary>
        </member>
        <member name="F:NewLife.Log.LogLevel.Debug">
            <summary>最低调试。细粒度信息事件对调试应用程序非常有帮助</summary>
        </member>
        <member name="F:NewLife.Log.LogLevel.Info">
            <summary>普通消息。在粗粒度级别上突出强调应用程序的运行过程</summary>
        </member>
        <me