Improve library documentation (#826)

* Improve the Command Service documentation

The following changes have been added to this PR:
•	Fix minor grammatical errors.
•	Capitalize terms such as Commands, Modules and such, as the context is specific to the lib.
•	Wrap methods and properties in code blocks.

The docs page currently has several issues that remains to be fixed.

1. 
```md
>[!WARNING]
>This article is out of date and has not been rewritten yet.
Information is not guaranteed to be accurate.
```

The docs doesn't necessarily seem "out of date" as the warning claims. The basics seem pretty relevant to the latest version of the lib.

2.
>“To manually load a module, invoke [CommandService.AddModuleAsync], by passing in the generic type of your module and optionally, a dependency map.”

The latter part of the sentence seems off. Where should the user pass the dependency map to? It seems to suggest that `AddModuleAsync` has an argument to pass the dependency to. If it is referring to `AddModuleAsync(Type type)`, then I feel like it should be clarified here - or perhaps change the wording of the sentence.

3.
>“First, you need to create an @System.IServiceProvider You may create your own IServiceProvider if you wish.” 

Any mention of @System.IServiceProvider is currently broken on the docs.

4.
>“Submodules are Modules that reside within another one. Typically, submodules are used to create nested groups (although not required to create nested groups).”

Clarification on the part after "although?"

5.
>“Finally, pass the map into the LoadAssembly method. Your modules will automatically be loaded with this dependency map.”

Where is this `LoadAssembly` method?

6.
```md
>[!NOTE]
>Preconditions can be applied to Modules, Groups, or Commands.
```

The docs should mention `ParameterPreconditionAttribute`'s existence.

* Update line breaks to comply with docs standard

* Change "you should..." to "instead, ..."

* Trim trailing spaces

* Change "inherits" to "inherit"

* Fix Context warning note and add ReplyAsync xref

* Fix broken xrefs

* Fix [Command Service] xref

* Fix consistency between TypeReaders and Preconditions returns

* Add missing semi-colons in ServiceProvider sample

* Change CommandContext to SocketCommandContext & change variable naming

* Cleanup TypeReader section

* Wrap [DontInject] in code block

* Fix commands docs linking in intro

* Improve Getting Started - Installation

- Fix character misalignment to comply with docs standard.
- Fix image numbering issues by moving the tooltips above some of the steps.
- Add codeblocks to search terms like `Discord.Net`.
- Remove broken `addons` reference.
- Specify `.NET 4.6.1` as `.NET Framework 4.6.1`.
- Minor cross-reference cleanup.

* Fix Getting Started - Intro

- Minor grammartical fixes.
- Wrap mentions of the methods, properties, and events in code block.
- Replace `Discord.Net` to `Discord.NET`.
- Fix steps numbering under `Creating a Discord Bot` and `Adding your bot to a server`.
- Change `Task-based Asynchronous Pattern ([TAP])` linking to mark the entire term instead.
- Change code block of `Pong!` to quotation mark instead.

* Fix cross references in Sending Voice

* Mention parameter precondition attribute

* Change `Discord.NET` to `Discord.Net` for consistency

* Wrap project names in code blocks & minor fixes in Terminology

* Change `add-ons` to `addons` for consistency

* Fix cross references in Logging

* Fix minor grammatical issues in "Working with Events"

* Missed a tilda

* Remove out-of-date warning in Commands

* Minor grammatical fixes for Entities

* Fix broken xref in Logging

* Adjust service collection sample

...according to f89aecb7bf (r141530227)

* Update Command Handler sample

- Update Main for C# 7.1.
- Inject CommandService and DiscordSocketClient into the service collection.
- Add Async suffix to asynchronous methods.

* Minor grammatical fixes in Events

* Revert 2 incorrect grammar corrections

* Revert async Main sample

* Add hardcode token notice in sample

* Fix missing method for Command Handler

* Modify module samples to use SocketCommandContext instead

* Emphasize CommandContext and SocketCommandContext

* Fix formatting for module sample

* Add SocketCommandContext for Groups sample

* Remove comma

* Fix DepMap sample formatting

* Replace [DontInject] with DontInjectAttribute with cross reference

* Remove connection logic note

There is no reason that this note should still be here since Ready event exists.

* Add a new warning message informing the users the existence of CommandService

* Make command handler private

excellent change

docs/guides/commands/samples/command_handler.cs

@@ -8,39 +8,42 @@ using Microsoft.Extensions.DependencyInjection;
 
 public class Program
 {
-    private CommandService commands;
-    private DiscordSocketClient client;
-    private IServiceProvider services;
+    private CommandService _commands;
+    private DiscordSocketClient _client;
+    private IServiceProvider _services;
 
-    static void Main(string[] args) => new Program().Start().GetAwaiter().GetResult();
+    private static void Main(string[] args) => new Program().StartAsync().GetAwaiter().GetResult();
 
-    public async Task Start()
+    public async Task StartAsync()
     {
-        client = new DiscordSocketClient();
-        commands = new CommandService();
+        _client = new DiscordSocketClient();
+        _commands = new CommandService();
 
+        // Avoid hard coding your token. Use an external source instead in your code.
         string token = "bot token here";
 
-        services = new ServiceCollection()
-                .BuildServiceProvider();
+        _services = new ServiceCollection()
+            .AddSingleton(_client)
+            .AddSingleton(_commands)
+            .BuildServiceProvider();
 
-        await InstallCommands();
+        await InstallCommandsAsync();
 
-        await client.LoginAsync(TokenType.Bot, token);
-        await client.StartAsync();
+        await _client.LoginAsync(TokenType.Bot, token);
+        await _client.StartAsync();
 
         await Task.Delay(-1);
     }
 
-    public async Task InstallCommands()
+    public async Task InstallCommandsAsync()
     {
         // Hook the MessageReceived Event into our Command Handler
-        client.MessageReceived += HandleCommand;
+        _client.MessageReceived += HandleCommandAsync;
         // Discover all of the commands in this assembly and load them.
-        await commands.AddModulesAsync(Assembly.GetEntryAssembly());
+        await _commands.AddModulesAsync(Assembly.GetEntryAssembly());
     }
 
-    public async Task HandleCommand(SocketMessage messageParam)
+    private async Task HandleCommandAsync(SocketMessage messageParam)
     {
         // Don't process the command if it was a System Message
         var message = messageParam as SocketUserMessage;
@@ -48,13 +51,13 @@ public class Program
         // Create a number to track where the prefix ends and the command begins
         int argPos = 0;
         // Determine if the message is a command, based on if it starts with '!' or a mention prefix
-        if (!(message.HasCharPrefix('!', ref argPos) || message.HasMentionPrefix(client.CurrentUser, ref argPos))) return;
+        if (!(message.HasCharPrefix('!', ref argPos) || message.HasMentionPrefix(_client.CurrentUser, ref argPos))) return;
         // Create a Command Context
-        var context = new CommandContext(client, message);
+        var context = new SocketCommandContext(_client, message);
         // Execute the command. (result does not indicate a return value, 
         // rather an object stating if the command executed successfully)
-        var result = await commands.ExecuteAsync(context, argPos, service);
+        var result = await _commands.ExecuteAsync(context, argPos, _services);
         if (!result.IsSuccess)
             await context.Channel.SendMessageAsync(result.ErrorReason);
     }
-}
+}

docs/guides/commands/samples/dependency_map_setup.cs

@@ -1,18 +1,18 @@
-using Discord;
-using Discord.Commands;
-using Discord.WebSocket;
-using foxboat.Services;
+private IServiceProvider _services;
+private CommandService _commands;
 
-public class Commands
+public async Task InstallAsync(DiscordSocketClient client)
 {
-    public async Task Install(DiscordSocketClient client)
-    {
-        // Here, we will inject the ServiceProvider with 
-        // all of the services our client will use.
-        _serviceCollection.AddSingleton(client)
-        _serviceCollection.AddSingleton(new NotificationService())
-        _serviceCollection.AddSingleton(new DatabaseService())
-        // ...
-        await _commands.AddModulesAsync(Assembly.GetEntryAssembly());
-    }
-}
+	// Here, we will inject the ServiceProvider with 
+	// all of the services our client will use.
+	_services = new ServiceCollection()
+		.AddSingleton(client)
+		.AddSingleton(_commands)
+		// You can pass in an instance of the desired type
+		.AddSingleton(new NotificationService())
+		// ...or by using the generic method.
+		.AddSingleton<DatabaseService>()
+		.BuildServiceProvider();
+	// ...
+	await _commands.AddModulesAsync(Assembly.GetEntryAssembly());
+}

docs/guides/commands/samples/empty-module.cs

@@ -1,6 +1,6 @@
 using Discord.Commands;
 
-public class InfoModule : ModuleBase
+public class InfoModule : ModuleBase<SocketCommandContext>
 {
     
 }

docs/guides/commands/samples/groups.cs

@@ -1,8 +1,8 @@
 [Group("admin")]
-public class AdminModule : ModuleBase
+public class AdminModule : ModuleBase<SocketCommandContext>
 {
     [Group("clean")]
-    public class CleanModule : ModuleBase
+    public class CleanModule : ModuleBase<SocketCommandContext>
     {
         // ~admin clean 15
         [Command]

docs/guides/commands/samples/module.cs

@@ -1,42 +1,41 @@
-using Discord;
-using Discord.Commands;
-using Discord.WebSocket;
-
 // Create a module with no prefix
-public class Info : ModuleBase
+public class Info : ModuleBase<SocketCommandContext>
 {
-    // ~say hello -> hello
-    [Command("say"), Summary("Echos a message.")]
-    public async Task Say([Remainder, Summary("The text to echo")] string echo)
-    {
-        // ReplyAsync is a method on ModuleBase
-        await ReplyAsync(echo);
-    }
+	// ~say hello -> hello
+	[Command("say")]
+	[Summary("Echos a message.")]
+	public async Task SayAsync([Remainder] [Summary("The text to echo")] string echo)
+	{
+		// ReplyAsync is a method on ModuleBase
+		await ReplyAsync(echo);
+	}
 }
 
 // Create a module with the 'sample' prefix
 [Group("sample")]
-public class Sample : ModuleBase
+public class Sample : ModuleBase<SocketCommandContext>
 {
-    // ~sample square 20 -> 400
-    [Command("square"), Summary("Squares a number.")]
-    public async Task Square([Summary("The number to square.")] int num)
-    {
-        // We can also access the channel from the Command Context.
-        await Context.Channel.SendMessageAsync($"{num}^2 = {Math.Pow(num, 2)}");
-    }
+	// ~sample square 20 -> 400
+	[Command("square")]
+	[Summary("Squares a number.")]
+	public async Task SquareAsync([Summary("The number to square.")] int num)
+	{
+		// We can also access the channel from the Command Context.
+		await Context.Channel.SendMessageAsync($"{num}^2 = {Math.Pow(num, 2)}");
+	}
 
-    // ~sample userinfo --> foxbot#0282
+	// ~sample userinfo --> foxbot#0282
 	// ~sample userinfo @Khionu --> Khionu#8708
 	// ~sample userinfo Khionu#8708 --> Khionu#8708
 	// ~sample userinfo Khionu --> Khionu#8708
 	// ~sample userinfo 96642168176807936 --> Khionu#8708
-    // ~sample whois 96642168176807936 --> Khionu#8708
-	[Command("userinfo"), Summary("Returns info about the current user, or the user parameter, if one passed.")]
-    [Alias("user", "whois")]
-    public async Task UserInfo([Summary("The (optional) user to get info for")] IUser user = null)
-    {
-        var userInfo = user ?? Context.Client.CurrentUser;
-        await ReplyAsync($"{userInfo.Username}#{userInfo.Discriminator}");
-    }
-}
+	// ~sample whois 96642168176807936 --> Khionu#8708
+	[Command("userinfo")]
+	[Summary("Returns info about the current user, or the user parameter, if one passed.")]
+	[Alias("user", "whois")]
+	public async Task UserInfoAsync([Summary("The (optional) user to get info for")] SocketUser user = null)
+	{
+		var userInfo = user ?? Context.Client.CurrentUser;
+		await ReplyAsync($"{userInfo.Username}#{userInfo.Discriminator}");
+	}
+}