Added Microsoft.Extensions.Hosting support

[GerardSmit]

This PR adds Microsoft.Extensions.Hosting support to Miki.Framework. This makes it way easier to set-up a new bot in a console application or even a ASP.NET Core application.

Middlewares

This PR introduces IBotApplicationBuilder which is equal to IApplicationBuilder in ASP.Net Core.

You can define middlewares in ConfigureBot:

HostBuilder.ConfigureBot(app =>
{
    app.Use(async (context, func) =>
    {
        var channel = await context.Message.GetChannelAsync();

        await channel.SendMessageAsync("Hello world!")
    });
})

Command pipeline

To use a command stage in the new middleware, you can use app.UseStage<ClassName>().
To use the CommandPipelineBuilder extensions, you can use app.UsePipeline:

app.UsePipeline(builder =>
{
    builder.UsePrefixes();
    builder.UseArgumentPack();
    builder.UseCommandHandler();
});

Example bot

public static Task Main(string[] args)
{
    return new HostBuilder()
        .ConfigureServices(services =>
        {
            services.AddDiscord("TOKEN");
            services.AddCacheClient<InMemoryCacheClient>();
            services.AddSingleton<ISerializer, ProtobufSerializer>();
        })
        .ConfigureBot(app =>
        {
            app.UseStage<FetchDataStage>();
            app.Use(async (context, next) =>
            {
                var message = context.Message;

                if (message.Content == "ping")
                {
                    await context.GetChannel().SendMessageAsync("Pong");
                }

                await next();
            });
        })
        .RunConsoleAsync();
}

[velddev]

Lets some questions and remarks

[velddev]

Why are these public now? they shouldn't be used externally.

[GerardSmit]

So you can easily add services when you make an extension method, e.g.:

public static class CommandExtensions
{
    public static CommandTreeBuilder AddWarningsModule(this CommandTreeBuilder builder)
    {
        builder.Services.AddScoped<IWarningService, WarningService>();
        builder.AddAssembly(typeof(CommandExtensions).Assembly);
        return builder;
    }
}

Now you can call the extension method AddWarningsModule and all the required services are added:

services.AddCommands(builder =>
{
    builder.AddWarningsModule();
});

[velddev]

Can we perhaps have any test cases for this?

[velddev]

What's the reasoning for this?

[GerardSmit]

This was needed when the delegate is being compiled, I need the parent type when creating the NodeExecutable:

https://github.com/Mikibot/Miki.Framework/blob/ede6821a96fc622a3e12c308dc2e73797dc816d4/src/Miki.Framework.Commands/CommandTreeCompiler.cs#L101

[velddev]

Is this before the pipeline?

[GerardSmit]

No, this is after the pipeline. This is called when an exception occurred in the middelware.

[velddev]

Can we add an event then when an exception occurs to fetch the current context state and exception?

[velddev]

"The message recieved from Discord" is deceiving, it will change into more providers in the future.

[velddev]

nani?

[GerardSmit]

The extension method .Run is being used at the end of the pipeline, so you don't need the next middleware. This is the same as ASP.NET Core.

[velddev]

App can't be null here right? Either way, you can use Required<IBotApplicationBuilder> to automate the process.

[GerardSmit]

App can't be null here right?

Probably not, this is how Microsoft implemented UseWhen as well but I can remove this.

Either way, you can use Required to automate the process.

Required<IBotApplicationBuilder> is not possible because it's an extension method. It would register the extension method to Required<IBotApplicationBuilder> instead of IBotApplicationBuilder.

[velddev]

Fair enough, but the other params could have it set to required.

[velddev]

How does this work?

[GerardSmit]

IExtendedCacheClient extends ICacheClient. This registration redirects ICacheClient to IExtendedCacheClient, you could register it two times but that means you have (for example) two Redis connections open.

[velddev]

That doesn't make sense, we already have connection pooling.