Merge pull request #503 from Joe4evr/DocSamples

Update doc samples

docs/guides/samples/dependency_map_setup.cs

@@ -7,18 +7,13 @@ public class Commands
 {
     public async Task Install(DiscordSocketClient client)
     {
-        var commands = new CommandService();
+        // Here, we will inject the Dependency Map with 
-        var map = new DependencyMap();
-        map.Add(client);
-        map.Add(commands);
-        await commands.AddModulesAsync(Assembly.GetEntryAssembly());
-    }
-    // In ConfigureServices, we will inject the Dependency Map with 
         // all of the services our client will use.
-    public Task ConfigureServices(IDependencyMap map)
+        _map.Add(client);
-    {
+        _map.Add(commands);
-        map.Add(new NotificationService(map));
+        _map.Add(new NotificationService(_map));
-        map.Add(new DatabaseService(map));
+        _map.Add(new DatabaseService(_map));
-    }
         // ...
+        await _commands.AddModulesAsync(Assembly.GetEntryAssembly());
+    }
 }

docs/guides/samples/dependency_module.cs

@@ -23,9 +23,9 @@ public class ModuleB
     private CommandService _commands;
     private NotificationService _notification;
     
-    public ModuleB(CommandService commands, IDependencyMap map)
+    public ModuleB(CommandService commands, NotificationService notifications)
     {
         _commands = commands;
-        _notification = map.Get<NotificationService>();
+        _notification = notifications;
     }
 }

docs/guides/samples/first-steps.cs

@@ -1,35 +1,128 @@
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
 using Discord;
+using Discord.Commands;
 using Discord.WebSocket;
 
 class Program
 {
-    // Convert our sync-main to an async main method
+    private readonly DiscordSocketClient _client;
-    static void Main(string[] args) => new Program().Run().GetAwaiter().GetResult();
     
-    // Create a DiscordClient with WebSocket support
+    // Keep the CommandService and IDependencyMap around for use with commands.
-    private DiscordSocketClient client;
+    private readonly IDependencyMap _map = new DependencyMap();
+    private readonly CommandService _commands = new CommandService();
 
-    public async Task Run()
+    // Program entry point
+    static void Main(string[] args)
     {
-        client = new DiscordSocketClient();
+        // Call the Program constructor, followed by the 
+        // MainAsync method and wait until it finishes (which should be never).
+        new Program().MainAsync().GetAwaiter().GetResult();
+    }
 
-        // Place the token of your bot account here
+    private Program()
-        string token = "aaabbbccc";
+    {
+        _client = new DiscordSocketClient(new DiscordSocketConfig
+        {
+            // How much logging do you want to see?
+            LogLevel = LogSeverity.Info,
             
-        // Hook into the MessageReceived event on DiscordSocketClient
+            // If you or another service needs to do anything with messages
-        client.MessageReceived += async (message) =>
+            // (eg. checking Reactions), you should probably
-        {   // Check to see if the Message Content is "!ping"
+            // set the MessageCacheSize here.
-            if (message.Content == "!ping")
+            //MessageCacheSize = 50,
-                // Send 'pong' back to the channel the message was sent in
-                await message.Channel.SendMessageAsync("pong");
-        };
 
-        // Configure the client to use a Bot token, and use our token
+            // If your platform doesn't have native websockets,
-        await client.LoginAsync(TokenType.Bot, token);
+            // add Discord.Net.Providers.WS4Net from NuGet,
-        // Connect the client to Discord's gateway
+            // add the `using` at the top, and uncomment this line:
-        await client.ConnectAsync();
+            //WebSocketProvider = WS4NetProvider.Instance
+        });
+    }
 
-        // Block this task until the program is exited.
+    // Create a named logging handler, so it can be re-used by addons
+    // that ask for a Func<LogMessage, Task>.
+    private static Task Logger(LogMessage message)
+    {
+        var cc = Console.ForegroundColor;
+        switch (message.Severity)
+        {
+            case LogSeverity.Critical:
+            case LogSeverity.Error:
+                Console.ForegroundColor = ConsoleColor.Red;
+                break;
+            case LogSeverity.Warning:
+                Console.ForegroundColor = ConsoleColor.Yellow;
+                break;
+            case LogSeverity.Info:
+                Console.ForegroundColor = ConsoleColor.White;
+                break;
+            case LogSeverity.Verbose:
+            case LogSeverity.Debug:
+                Console.ForegroundColor = ConsoleColor.DarkGray;
+                break;
+        }
+        Console.WriteLine($"{DateTime.Now,-19} [{message.Severity,8}] {message.Source}: {message.Message}");
+        Console.ForegroundColor = cc;
+        return Task.CompletedTask;
+    }
+
+    private async Task MainAsync()
+    {
+        // Subscribe the logging handler.
+        _client.Log += Logger;
+
+        // Centralize the logic for commands into a seperate method.
+        await InitCommands();
+
+        // Login and connect.
+        await _client.LoginAsync(TokenType.Bot, /* <DON'T HARDCODE YOUR TOKEN> */);
+        await _client.ConnectAsync();
+        
+        // Wait infinitely so your bot actually stays connected.
         await Task.Delay(-1);
     }
+
+    private async Task InitCommands()
+    {
+        // Repeat this for all the service classes
+        // and other dependencies that your commands might need.
+        _map.Add(new SomeServiceClass());
+
+        // Either search the program and add all Module classes that can be found:
+        await _commands.AddModulesAsync(Assembly.GetEntryAssembly());
+        // Or add Modules manually if you prefer to be a little more explicit:
+        await _commands.AddModuleAsync<SomeModule>();
+
+        // Subscribe a handler to see if a message invokes a command.
+        _client.MessageReceived += CmdHandler;
+    }
+
+    private async Task CmdHandler(SocketMessage arg)
+    {
+        // Bail out if it's a System Message.
+        var msg = arg as SocketUserMessage;
+        if (msg == null) return;
+
+        // Create a number to track where the prefix ends and the command begins
+        int pos = 0;
+        // Replace the '!' with whatever character
+        // you want to prefix your commands with.
+        // Uncomment the second half if you also want
+        // commands to be invoked by mentioning the bot instead.
+        if (msg.HasCharPrefix('!', ref pos) /* || msg.HasMentionPrefix(msg.Discord.CurrentUser, ref pos) */)
+        {
+            // Create a Command Context
+            var context = new SocketCommandContext(msg.Discord, msg);
+            
+            // Execute the command. (result does not indicate a return value, 
+            // rather an object stating if the command executed succesfully).
+            var result = await _commands.ExecuteAsync(context, pos, _map);
+
+            // Uncomment the following lines if you want the bot
+            // to send a message if it failed (not advised for most situations).
+            //if (!result.IsSuccess && result.Error != CommandError.UnknownCommand)
+            //    await msg.Channel.SendMessageAsync(result.ErrorReason);
+        }
+    }
 }

docs/guides/samples/logging.cs

@@ -3,13 +3,13 @@ using Discord.Rest;
 
 public class Program
 {
-    // Note: This is the light client, it only supports REST calls.
+    // Note: This is the REST client, it only supports REST calls.
     private DiscordClient _client;
     static void Main(string[] args) => new Program().Start().GetAwaiter().GetResult();
     
     public async Task Start()
     {
-        _client = new DiscordClient(new DiscordConfig() {
+        _client = new DiscordRestClient(new DiscordConfig() {
 			LogLevel = LogSeverity.Info
         });