Do Command modules support Scoped services?

[defunky]

I'm basing my question on the dependency injection guide provided here.

From what I've read the AddModulesAsync() method registers modules with a transient scope, with CommandService registered as a Singleton. If that's the case, registering scoped service inside of a Module should be fine, however doing so seems to trigger Cannot resolve scoped service '...' from root provider.

I'm currently bypassing this check via ValidateScopes in the ServiceProviderOptions however I'm not sure if this is the right approach?

[BobVul]

You need to:

1. Create a service scope when handling a command
2. Pass in the new scope when executing the command
3. Dispose the scope after command execution is complete

---

In the following example I assume you're using the CommandHandler from the documentation.

1. You should first make sure you have correct post-execution handling for RunMode.Async commands, as described in this documentation.

2. Create a new SocketCommandContext subclass that implements IDisposable, like so:

   public class ScopedSocketCommandContext : SocketCommandContext, IDisposable
   {
       private bool disposedValue;
       public IServiceScope ServiceScope { get; }
   
       public ScopedSocketCommandContext(DiscordSocketClient client, SocketUserMessage msg, IServiceProvider services) : base(client, msg)
       {
           ServiceScope = services.CreateScope();
       }
   
       protected virtual void Dispose(bool disposing)
       {
           if (!disposedValue)
           {
               if (disposing)
               {
                   ServiceScope.Dispose();
               }
   
               disposedValue = true;
           }
       }
   
       public void Dispose()
       {
           Dispose(disposing: true);
           GC.SuppressFinalize(this);
       }
   }

3. The rest of the changes will be in your CommandHandler service. You will need to inject a IServiceProvider into it.

   public CommandHandler(..., IServiceProvider services)
   {
       _services = services;
   }

4. Next, in your MessageReceivedHandler where you construct your SocketCommandContext, instead construct a ScopedSocketCommandContext:

   var context = new ScopedSocketCommandContext(client, message, _services);

5. Where you execute your commands, pass in your new scoped service provider (currently referenced from the context):

   await _commands.ExecuteAsync(
       context: context, 
       argPos: argPos,
       services: context.ServiceScope.ServiceProvider);

6. At the end of your OnCommandExecutedAsync you need to dispose of the service scope.

   if (context is ScopedSocketCommandContext scopedContext)
   {
       scopedContext.Dispose();
   }

7. You will also need to wrap the module discovery in InstallCommandsAsync, since that instantiates the modules and you'll get an error here if scope validation is enabled.

   using (var scope = serviceProvider.CreateScope())
   {
       await _commands.AddModulesAsync(assembly: Assembly.GetEntryAssembly(),
           services: scope.ServiceProvider);
   }