Class SocketCommandContext

Namespace

Discord.Commands

Assembly

Discord.Net.WebSocket.dll

Represents a WebSocket-based context of a command. This may include the client, guild, channel, user, and message.

public class SocketCommandContext : ICommandContext

Inheritance

object

SocketCommandContext

Implements

ICommandContext

Derived

ShardedCommandContext

Inherited Members

object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ReferenceEquals(object, object)

object.ToString()

Examples

An example of how this class is used the command system can be seen below:

using Discord.Commands;

// Keep in mind your module **must** be public and inherit ModuleBase.
// If it isn't, it will not be discovered by AddModulesAsync!
public class InfoModule : ModuleBase<SocketCommandContext>
{
    
}

public class CommandHandler
{
    private readonly DiscordSocketClient _client;
    private readonly CommandService _commands;

    // Retrieve client and CommandService instance via ctor
    public CommandHandler(DiscordSocketClient client, CommandService commands)
    {
        _commands = commands;
        _client = client;
    }
    
    public async Task InstallCommandsAsync()
    {
        // Hook the MessageReceived event into our command handler
        _client.MessageReceived += HandleCommandAsync;

        // Here we discover all of the command modules in the entry 
        // assembly and load them. Starting from Discord.NET 2.0, a
        // service provider is required to be passed into the
        // module registration method to inject the 
        // required dependencies.
        //
        // If you do not use Dependency Injection, pass null.
        // See Dependency Injection guide for more information.
        await _commands.AddModulesAsync(assembly: Assembly.GetEntryAssembly(), 
                                        services: null);
    }

    private async Task HandleCommandAsync(SocketMessage messageParam)
    {
        // Don't process the command if it was a system message
        var message = messageParam as SocketUserMessage;
        if (message == null) return;

        // 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 the prefix and make sure no bots trigger commands
        if (!(message.HasCharPrefix('!', ref argPos) || 
            message.HasMentionPrefix(_client.CurrentUser, ref argPos)) ||
            message.Author.IsBot)
            return;

        // Create a WebSocket-based command context based on the message
        var context = new SocketCommandContext(_client, message);

        // Execute the command with the command context we just
        // created, along with the service provider for precondition checks.
        await _commands.ExecuteAsync(
            context: context, 
            argPos: argPos,
            services: null);
    }
}

Constructors

SocketCommandContext(DiscordSocketClient, SocketUserMessage)

Initializes a new SocketCommandContext class with the provided client and message.

public SocketCommandContext(DiscordSocketClient client, SocketUserMessage msg)

Parameters

client DiscordSocketClient

The underlying client.

msg SocketUserMessage

The underlying message.

Properties

Channel

Gets the ISocketMessageChannel that the command is executed in.

public ISocketMessageChannel Channel { get; }

Property Value

ISocketMessageChannel

Client

Gets the DiscordSocketClient that the command is executed with.

public DiscordSocketClient Client { get; }

Property Value

DiscordSocketClient

Guild

Gets the SocketGuild that the command is executed in.

public SocketGuild Guild { get; }

Property Value

SocketGuild

IsPrivate

Indicates whether the channel that the command is executed in is a private channel.

public bool IsPrivate { get; }

Property Value

bool

Message

Gets the SocketUserMessage that the command is interpreted from.

public SocketUserMessage Message { get; }

Property Value

SocketUserMessage

User

Gets the SocketUser who executed the command.

public SocketUser User { get; }

Property Value

SocketUser