fix markdown format warnings

Author: WeihanLi

Basics.md

@@ -40,6 +40,7 @@ ConnectionMultiplexer redis = ConnectionMultiplexer.Connect("server1:6379,server
 ```C#
 IDatabase db = redis.GetDatabase();
 ```
+
 从 `GetDatabase` 返回的对象是一个成本很低的通道对象，不需要存储。
 注意，redis支持多个数据库（虽然“集群”不支持），这可以可选地在调用 `GetDatabase` 中指定。
 此外，如果您计划使用异步API，您需要 [`Task.AsyncState`][2] 有一个值，也可以指定：
@@ -50,7 +51,7 @@ object asyncState = ...
 IDatabase db = redis.GetDatabase(databaseNumber, asyncState);
 ```
 
-一旦你有了`IDatabase`，它只是一个使用 [redis API](http://redis.io/commands) 的情况。 
+一旦你有了`IDatabase`，它只是一个使用 [redis API](http://redis.io/commands) 的情况。
 注意，所有方法都具有同步和异步实现。 
 根据微软的命名指导，异步方法都以 `...Async(...)` 结尾，并且完全是可以等待的 `await` 等。
 
@@ -74,7 +75,7 @@ db.StringSet(key, value);
 byte[] value = db.StringGet(key);
 ```
 
-覆盖所有redis数据类型的所有 [redis数据库命令]（http://redis.io/commands）的都是可以使用的。
+覆盖所有redis数据类型的所有 [redis数据库命令](http://redis.io/commands) 的都是可以使用的。
 
 使用 redis 发布/订阅
 ----
@@ -106,7 +107,7 @@ sub.Publish("messages", "hello");
 
 这将（实际上瞬间）将“hello”写到订阅进程的控制台。 和之前一样，通道名和消息都可以是二进制的。
 
-有关顺序和并发消息处理的使用文档说明，请参见 [发布/订阅消息顺序](PubSubOrder.md) 。
+有关顺序和并发消息处理的使用文档说明，请参见 [发布/订阅消息顺序](./PubSubOrder.md) 。
 
 访问单独的服务器
 ---
@@ -140,13 +141,10 @@ StackExchange.Redis有3种主要使用机制：
 
 - 同步 - 适用于操作在方法返回到调用者之前完成（注意，尽管这可能阻止调用者，但它绝对**不会**阻止其他线程：StackExchange.Redis的关键思想是它积极地与并发调用者共享连接）
 
-- Asynchronous - where the operation completes some time in the future, and a `Task` or `Task<T>` is returned immediately, which can later:
-
 - 异步 - 操作在将来完成一些时间，并且立即返回一个 `Task` 或 'Task<T>' 对象，也可以稍后再返回：
-
- - 是可以等待的（阻塞当前线程，直到响应可用） `.Wait()`
- - 可以增加一个后续的回调 (TPL 中的 [`ContinueWith`](http://msdn.microsoft.com/en-us/library/system.threading.tasks.task.continuewith(v=vs.110).aspx))
- - *awaited* 可等待的（这是简化后者的语言级特性，同时如果答复已经知道也立即继续） 
+  - 是可以等待的（阻塞当前线程，直到响应可用） `.Wait()`
+  - 可以增加一个后续的回调 (TPL 中的 [`ContinueWith`](http://msdn.microsoft.com/en-us/library/system.threading.tasks.task.continuewith(v=vs.110).aspx))
+  - *awaited* 可等待的（这是简化后者的语言级特性，同时如果答复已经知道也立即继续
 
 - 执行后不理 - 适用于你真的对这个回复不感兴趣，并且乐意继续不管回应
 
@@ -173,6 +171,6 @@ db.StringIncrement(pageKey, flags: CommandFlags.FireAndForget);
 [查看原文](https://github.com/StackExchange/StackExchange.Redis/blob/master/docs/Basics.md)
 ---
 
-  [1]: http://msdn.microsoft.com/en-us/library/dd460717%28v=vs.110%29.aspx
-  [2]: http://msdn.microsoft.com/en-us/library/system.threading.tasks.task.asyncstate(v=vs.110).aspx
-  [3]: http://msdn.microsoft.com/en-us/library/system.string(v=vs.110).aspx
+[1]: http://msdn.microsoft.com/en-us/library/dd460717%28v=vs.110%29.aspx
+[2]: http://msdn.microsoft.com/en-us/library/system.threading.tasks.task.asyncstate(v=vs.110).aspx
+[3]: http://msdn.microsoft.com/en-us/library/system.string(v=vs.110).aspx

Configuration.md

@@ -203,24 +203,25 @@ The configuration message can also be used separately to master/slave changes si
 ReconnectRetryPolicy可以是线性的（默认），指数的或者是一个自定义的重试策略。
 
 举个例子：
+
 ```C#
 config.ReconnectRetryPolicy = new ExponentialRetry(5000); // defaults maxDeltaBackoff to 10000 ms
 //retry#    retry to re-connect after time in milliseconds
-//1	        a random value between 5000 and 5500	   
-//2	        a random value between 5000 and 6050	   
-//3	        a random value between 5000 and 6655	   
-//4	        a random value between 5000 and 8053
-//5	        a random value between 5000 and 10000, since maxDeltaBackoff was 10000 ms
-//6	        a random value between 5000 and 10000
+//1         a random value between 5000 and 5500
+//2         a random value between 5000 and 6050
+//3         a random value between 5000 and 6655
+//4         a random value between 5000 and 8053
+//5         a random value between 5000 and 10000, since maxDeltaBackoff was 10000 ms
+//6         a random value between 5000 and 10000
 
 config.ReconnectRetryPolicy = new LinearRetry(5000); 
 //retry#    retry to re-connect after time in milliseconds
-//1	        5000 
-//2	        5000 	   
-//3	        5000 	   
-//4	        5000 
-//5	        5000 
-//6	        5000 
+//1         5000
+//2         5000
+//3         5000
+//4         5000
+//5         5000
+//6         5000
 ```
 
 [查看原文](https://github.com/StackExchange/StackExchange.Redis/blob/master/docs/Configuration.md)

KeysScan.md

@@ -55,7 +55,7 @@ server.FlushDatabase();
 
 注意，与 `IDatabase` API（在 `GetDatabase()` 调用中已经选择了的目标数据库）不同，这些方法对数据库使用可选参数，或者默认为`0`。
 
-`Keys(...)` 方法值得特别一提：它并不常见，因为它没有一个 `*Async` 对应。 这样做的原因是，在后台，系统将确定使用最合适的方法（基于服务器版本的 `KEYS` VS `SCAN`），如果可能的话，将使用 `SCAN` 方法 一个 `IEnumerable<RedisKey>` 在内部执行所有的分页 - 所以你永远不需要看到游标操作的实现细节。 
+`Keys(...)` 方法值得特别一提：它并不常见，因为它没有一个 `*Async` 对应。 这样做的原因是，在后台，系统将确定使用最合适的方法（基于服务器版本的 `KEYS` VS `SCAN`），如果可能的话，将使用 `SCAN` 方法 一个 `IEnumerable<RedisKey>` 在内部执行所有的分页 - 所以你永远不需要看到游标操作的实现细节。
 如果 `SCAN` 不可用，它将使用 `KEYS`，这可能导致服务器上的阻塞。 无论哪种方式，`SCAN` 和 `KEYS` 都需要扫描整个键空间，所以在生产服务器上应该避免 - 或者至少是针对从节点服务器。
 
 所以我需要记住我连接到哪个服务器？ 这真糟糕！

PipelinesMultiplexers.md

@@ -3,7 +3,6 @@
 
 延迟严重。现代计算机可以以惊人的速度搅动数据，并且高速网络（通常具有在重要服务器之间的多个并行链路）提供巨大的带宽，但是... 该延迟意味着计算机花费大量的时间*等待数据* 和 这是基于连续的编程越来越受欢迎的几个原因之一。
 
-
 让我们考虑一些常规的程序代码：
 
 ```C#
@@ -33,7 +32,7 @@ string b = db.StringGet("b");
                                      [====waiting=====]
                                                       [resp2]
 
-请记住，这是**不成比例的** - 如果这是按时间缩放，它将是完全由` waiting`  控制的。
+请记住，这是**不成比例的** - 如果这是按时间缩放，它将是完全由 `waiting` 控制的。
 
 管道线
 ---
@@ -42,7 +41,7 @@ string b = db.StringGet("b");
 在 .NET 中，可以启动但尚未完成，并且可能以后完成或故障的由TPL封装的操作可以由 [TPL][1] 通过 [`Task`][2] / [`Task <T>`][3] API 来实现。
 本质上， `Task<T>` 表示 " `T` 类型未来可能的值"（非泛型的 `Task` 本质尚是 `Task<void>` ）。你可以使用任意一种用法：
 
--  在稍后的代码块等待直到操作完成（`.Wait()`）
+- 在稍后的代码块等待直到操作完成（`.Wait()`）
 - 当操作完成时，调度一个后续操作（`.ContinueWith(...)` 或 `await`）
 
 例如，要使用过程化（阻塞）代码来借助管道传递这两个 get 操作，我们可以使用：
@@ -76,8 +75,8 @@ var value = (string)db.StringGet(key);
 ---
 
 管道是很好的，但是通常任何单个代码块只需要一个值（或者可能想要执行几个操作，但是依赖于彼此）。
-这意味着我们仍然有一个问题，我们花大部分时间等待数据在客户端和服务器之间传输。 
-现在考虑一个繁忙的应用程序，也许是一个Web服务器。 
+这意味着我们仍然有一个问题，我们花大部分时间等待数据在客户端和服务器之间传输。
+现在考虑一个繁忙的应用程序，也许是一个Web服务器。
 这样的应用程序通常是并发的，所以如果你有20个并行应用程序请求都需要数据，你可能会想到旋转20个连接，或者你可以同步访问单个连接（这意味着最后一个调用者需要等待 延迟的所有其他19之前，甚至开始）。 或者折中一下，也许一个5个连接的租赁池 - 无论你怎么做，都会有很多的等待。
 **StackExchange.Redis不做这个**; 相反，它做 *很多* 的工作，使你有效地利用所有这个空闲时间*复用* 一个连接。
 当不同的调用者同时使用它时，它**自动把这些单独的请求加入管道**，所以不管请求使用阻塞还是异步访问，工作都是按进入管道的顺序处理的。
@@ -127,6 +126,6 @@ return value;
 [查看原文](https://github.com/StackExchange/StackExchange.Redis/blob/master/docs/PipelinesMultiplexers.md)
 ---
 
-  [1]: http://msdn.microsoft.com/en-us/library/dd460717(v=vs.110).aspx
-  [2]: http://msdn.microsoft.com/en-us/library/system.threading.tasks.task(v=vs.110).aspx
-  [3]: http://msdn.microsoft.com/en-us/library/dd321424(v=vs.110).aspx
+[1]: http://msdn.microsoft.com/en-us/library/dd460717(v=vs.110).aspx
+[2]: http://msdn.microsoft.com/en-us/library/system.threading.tasks.task(v=vs.110).aspx
+[3]: http://msdn.microsoft.com/en-us/library/dd321424(v=vs.110).aspx

Profiling.md

@@ -3,7 +3,7 @@
 
 性能分析的 API 发生了很大变化从 `1.*` 到 `2.*` 版本。
 
-在 `1.*` 版本，特别是 `object GetContext()` API 对于消费者来说是不直观的，对于库而言是昂贵的（由于 book-keeping）。
+在 `1.*` 版本，特别是 `object GetContext()` API 对于消费者来说是不直观的，对于类库而言是昂贵的（由于 book-keeping）。
 在 `2.*` 版本，这个 API 更加简单，更加 “明显”。
 
 这是一个巨大变化。

README.md

@@ -35,7 +35,7 @@ StackExchange.Redis 是 Stackoverflow 开发的 Redis C# 客户端，是目前.n
 - [键查找](KeysScan.md)
 - [键与值](KeysValues.md)
 - [管道与重用链接](PipelinesMultiplexers.md)
-- [分析](Profiling.md)
+- [性能分析](Profiling.md)
 - [发布订阅顺序](PubSubOrder.md)
 - [脚本](Scripting.md)
 - [超时](Timeouts.md)

SUMMARY.md

@@ -7,7 +7,7 @@
 * [键查找](KeysScan.md)
 * [键与值](KeysValues.md)
 * [管道与重用链接](PipelinesMultiplexers.md)
-* [分析](Profiling.md)
+* [性能分析](Profiling.md)
 * [发布订阅顺序](PubSubOrder.md)
 * [脚本](Scripting.md)
 * [超时](Timeouts.md)

Scripting.md

@@ -8,16 +8,16 @@
 
 `LuaScript` 的使用示例:
 
-```
-	const string Script = "redis.call('set', @key, @value)";
+``` csharp
+const string Script = "redis.call('set', @key, @value)";
 
-	using (ConnectionMultiplexer conn = /* init code */)
-	{
-		var db = conn.GetDatabase(0);
+using (ConnectionMultiplexer conn = /* init code */)
+{
+    var db = conn.GetDatabase(0);
 
-		var prepared = LuaScript.Prepare(Script);
-		db.ScriptEvaluate(prepared, new { key = (RedisKey)"mykey", value = 123 });
-	}
+    var prepared = LuaScript.Prepare(Script);
+    db.ScriptEvaluate(prepared, new { key = (RedisKey)"mykey", value = 123 });
+}
 ```
 
 `LuaScript` 类将 `@myVar` 形式的脚本中的变量重写为redis所需的合适的 `ARGV [someIndex]`。 
@@ -30,32 +30,32 @@ Any object that exposes field or property members with the same name as @-prefix
 
 支持的成员类型如下：
 
- - int(?)
- - long(?)
- - double(?)
- - string
- - byte[]
- - bool(?)
- - RedisKey
- - RedisValue
+- int(?)
+- long(?)
+- double(?)
+- string
+- byte[]
+- bool(?)
+- RedisKey
+- RedisValue
 
 为了避免在每次评估时重新传输Lua脚本到redis，`LuaScript` 对象可以通过 `LuaScript.Load(IServer)` 转换为 `LoadedLuaScript`。
 `LoadedLuaScripts` 使用 [`EVALSHA`](http://redis.io/commands/evalsha) 求值，并由 hash 引用。
 
 `LoadedLuaScript` 的使用示例：
 
-```
-	const string Script = "redis.call('set', @key, @value)";
+``` csharp
+const string Script = "redis.call('set', @key, @value)";
 
-	using (ConnectionMultiplexer conn = /* init code */)
-	{
-		var db = conn.GetDatabase(0);
-		var server = conn.GetServer(/* appropriate parameters*/);
+using (ConnectionMultiplexer conn = /* init code */)
+{
+    var db = conn.GetDatabase(0);
+    var server = conn.GetServer(/* appropriate parameters*/);
 
-		var prepared = LuaScript.Prepare(Script);
-		var loaded = prepared.Load(server);
-		loaded.Evaluate(db, new { key = (RedisKey)"mykey", value = 123 });
-	}
+    var prepared = LuaScript.Prepare(Script);
+    var loaded = prepared.Load(server);
+    loaded.Evaluate(db, new { key = (RedisKey)"mykey", value = 123 });
+}
 ```
 
 `LuaScript` 和 `LoadedLuaScript` 上的所有方法都有Async替代方法，并将提交到redis的实际脚本公开为 `ExecutableScript` 属性。

Timeouts.md

@@ -1,5 +1,5 @@
 你是否正遇到网络或 CPU 的瓶颈？
----------------
+==============
 
 验证客户端和托管redis-server的服务器上支持的最大带宽。如果有请求被带宽限制，则它们需要更长时间才能完成，从而可能导致超时。
 同样，验证您没有在客户端或服务器框上获得CPU限制，这将导致请求等待CPU时间，从而超时。
@@ -25,6 +25,7 @@
 
 在超时异常中，是否有很多 busyio 或 busyworker 线程？
 ---------------
+
 让我们先了解一下 ThreadPool 增长的一些细节：
 
 CLR ThreadPool有两种类型的线程 - “工作线程”和“I/O 完成端口”（也称为 IOCP）线程。
@@ -58,17 +59,19 @@ CLR ThreadPool有两种类型的线程 - “工作线程”和“I/O 完成端
 
 建议：
 
-鉴于上述信息，建议将 IOCP 和 WORKER 线程的最小配置值设置为大于默认值的值。 我们不能给出一个大小适合所有指导这个值应该是什么，因为对于一个应用程序的正确的值对于另一个应用程序而言总会太高/低。 
+鉴于上述信息，建议将 IOCP 和 WORKER 线程的最小配置值设置为大于默认值的值。 我们不能给出一个大小适合所有指导这个值应该是什么，因为对于一个应用程序的正确的值对于另一个应用程序而言总会太高/低。
 此设置也会影响复杂应用程序的其他部分的性能，因此您需要根据您的特定需求调整此设置。 
 一个好的起点是200或300，然后根据需要进行测试和调整。
 
 如何配置这个设置：
 
-- 在 ASP.NET 中，使用 machine.config 中 `<processModel>` 配置元素下的[“minIoThreads”配置设置](https://msdn.microsoft.com/en-us/library/7w2sway1(v=vs.71).aspx)。 根据微软的做法，你不能修改每个站点 web.config 中的这个值（即使你过去这样做是可以的），如果你这样改的话你所有的.NET 站点都会使用这个设置的值。
+- 在 ASP.NET 中，使用 machine.config 中 `<processModel>` 配置元素下的
+[“minIoThreads”配置设置](https://msdn.microsoft.com/en-us/library/7w2sway1(v=vs.71).aspx)。
+根据微软的做法，你不能修改每个站点 web.config 中的这个值（即使你过去这样做是可以的），如果你这样改的话你所有的.NET 站点都会使用这个设置的值。
 请注意如果你设置 `autoconfig` 为 `false` 是不需要添加每一个属性的，仅需要添加 `autoconfig="false"` 并且覆盖原来的值就可以了：
 `<processModel autoConfig="false" minIoThreads="250" />`
 
-> **重要说明：** 此配置元素中指定的值是为*每个核* 设置。例如，如果你有一个4核的机器，并希望你的 minIthreads 设置为200在运行时，你应该使用 `<processModel minIoThreads ="50"/>`。
+  > **重要说明：** 此配置元素中指定的值是为*每个核* 设置。例如，如果你有一个4核的机器，并希望你的 minIthreads 设置为200在运行时，你应该使用 `<processModel minIoThreads ="50"/>`。
 
 - 在 ASP.NET 之外，使用 [ThreadPool.SetMinThreads(...)](https://msdn.microsoft.com//en-us/library/system.threading.threadpool.setminthreads(v=vs.100).aspx)API。
 

Transactions.md

@@ -18,14 +18,14 @@ redis中的事务包括放置在 `MULTI` 和 `EXEC` 之间的一组命令（或
 var newId = CreateNewUniqueID(); // optimistic
 using(var tran = conn.BeginTran())
 {
-	var cust = GetCustomer(conn, custId, tran);
-	var uniqueId = cust.UniqueID;
-	if(uniqueId == null)
-	{
-		cust.UniqueId = newId;
-		SaveCustomer(conn, cust, tran);
-	}
-	tran.Complete();
+    var cust = GetCustomer(conn, custId, tran);
+    var uniqueId = cust.UniqueID;
+    if(uniqueId == null)
+    {
+        cust.UniqueId = newId;
+        SaveCustomer(conn, cust, tran);
+    }
+    tran.Complete();
 }
 ```
 
@@ -38,7 +38,7 @@ using(var tran = conn.BeginTran())
 Redis会自动跟踪这个键，任何变化基本上都会使我们的事务回滚 - `EXEC` 和 `DISCARD` 一样（调用者可以检测到这一点，并从头开始重试）。
 所以你可以做的是： `WATCH` 一个键，以正常的方式检查该键的数据，然后 `MULTI` / `EXEC` 你的更改。
 
-如果，当你检查数据，你发现你实际上不需要事务，你可以使用 `UNWATCH` 来取消关注所有关注的键。 
+如果，当你检查数据，你发现你实际上不需要事务，你可以使用 `UNWATCH` 来取消关注所有关注的键。
 注意，关注的键在 `EXEC` 和 `DISCARD` 期间也被复位。 所以*在Redis层*，事务是从概念上讲的。
 
 ```
@@ -104,7 +104,7 @@ Lua 脚本
 
 在Redis层（假设 `HSETNX` 不存在），这可以实现为：
 
-```
+``` lua
 EVAL "if redis.call('hexists', KEYS[1], 'UniqueId') then return redis.call('hset', KEYS[1], 'UniqueId', ARGV[1]) else return 0 end" 1 {custKey} {newId}
 ```