Discord Бот игнорирует команды

using System;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using System.Text;
using Microsoft.Extensions.DependencyInjection;
using Discord;
using Discord.Commands;
using Discord.WebSocket;
using ComputerTeamBotDiscord.Services;
 
namespace ComputerTeamBotDiscord
{
    public class Program
    {
        private DiscordSocketClient _client;
        CommandHandler _handler;
        CommandService _command;
        IServiceProvider _service;
 
        public static void Main(string[] args)
            => new Program().MainAsync().GetAwaiter().GetResult();
 
        public async Task MainAsync()
        {
            _client = new DiscordSocketClient();
 
            _client.Log += Log;
 
            var token = "мой токен";
 
            await _client.LoginAsync(TokenType.Bot, token);
            await _client.StartAsync();
 
            await Task.Delay(-1);
        }
 
        private Task Log(LogMessage msg)
        {
            Console.WriteLine(msg.ToString());
            return Task.CompletedTask;
        }
    }
}

using Discord;
using Discord.Net;
using Discord.WebSocket;
using Discord.Commands;
using System;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections.Generic;
using Microsoft.Extensions.Configuration;
 
namespace ComputerTeamBotDiscord.Modules
{
    public class CmdTest : ModuleBase<SocketCommandContext>
    {
        [Command("say")]
        public async Task SayTask()
        {
            await Context.Channel.SendMessageAsync("SPO-SILA!");
        }
    }
}

using Discord.Commands;
using Discord.WebSocket;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
 
namespace ComputerTeamBotDiscord.Services
{
    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);
            }
      }
}