Discord.Net机器人异步任务间类变量共享问题咨询

我之前开发Discord.Net机器人时也踩过这个坑！默认情况下，Discord.Net会为每个命令请求创建模块的新实例，所以你定义的test类变量每次都会被重置为null，这就是为什么initializeString之后调用addToString还是取不到值的原因。

不用文件或数据库的话，这里有几个轻量且支持多并发的方案，根据你的需求选就行：

方案1：静态字段（适合全局共享状态） #

如果你的字符串是所有用户共用的，直接把test改成静态字段就行——静态字段属于类本身，不会随模块实例销毁而重置：

using Discord.Commands;
using System.Threading.Tasks;

namespace UsefulDiscordBot.Modules
{
    public class Foo : ModuleBase<SocketCommandContext>
    {
        // 静态字段：全局唯一，所有模块实例共享
        private static string test;

        [Command("initializeString")]
        public async Task initializeString()
        {
            test = "Initialized";
            await ReplyAsync("全局字符串已初始化！");
        }

        [Command("addToString")]
        public async Task addToString([Remainder]string s)
        {
            if (test == null)
            {
                await ReplyAsync("请先使用!initializeString初始化全局字符串！");
                return;
            }
            test += s;
            await ReplyAsync("已添加内容到全局字符串！");
        }

        [Command("printString")]
        public async Task printString()
        {
            await ReplyAsync(test ?? "全局字符串未初始化！");
        }
    }
}

⚠️ 注意：静态字段是全局共享的，所有用户调用命令都会修改同一个字符串，适合全局状态，不适合用户专属的私有数据。

方案2：依赖注入单例状态类（推荐，支持用户/服务器隔离） #

如果需要每个用户（或服务器）有独立的字符串，推荐用依赖注入注册一个单例的状态管理类——这个类会在机器人启动时创建一次，一直存在到机器人关闭，完美解决实例重置的问题。

第一步：创建状态管理类 #

using System.Collections.Concurrent;

namespace UsefulDiscordBot.Services
{
    // 专门管理字符串状态的服务类
    public class StringStateService
    {
        // 用ConcurrentDictionary保证多并发下的线程安全
        private readonly ConcurrentDictionary<ulong, string> _userStrings = new ConcurrentDictionary<ulong, string>();

        // 初始化用户的字符串
        public void InitializeUserString(ulong userId)
        {
            _userStrings[userId] = "Initialized";
        }

        // 给用户的字符串追加内容
        public bool AppendToUserString(ulong userId, string content)
        {
            // 先检查用户是否已初始化
            if (!_userStrings.ContainsKey(userId))
                return false;
            
            _userStrings[userId] += content;
            return true;
        }

        // 获取用户的字符串
        public string GetUserString(ulong userId)
        {
            _userStrings.TryGetValue(userId, out var str);
            return str;
        }
    }
}

这里用ConcurrentDictionary代替普通Dictionary，是为了应对多命令并发调用时的线程安全问题，避免出现数据异常。

第二步：注册单例服务 #

在机器人启动的Host配置里，把这个状态类注册为单例：

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Discord.WebSocket;
using Discord.Commands;
using UsefulDiscordBot.Services;

var host = Host.CreateDefaultBuilder()
    .ConfigureServices(services =>
    {
        // 注册单例状态服务
        services.AddSingleton<StringStateService>();
        // 注册Discord相关服务
        services.AddSingleton<DiscordSocketClient>();
        services.AddSingleton<CommandService>();
        // 其他服务注册...
    })
    .Build();

// 后续启动逻辑...

第三步：在模块中注入并使用 #

修改你的Foo模块，通过构造函数注入状态服务：

using Discord.Commands;
using System.Threading.Tasks;
using UsefulDiscordBot.Services;

namespace UsefulDiscordBot.Modules
{
    public class Foo : ModuleBase<SocketCommandContext>
    {
        private readonly StringStateService _stateService;

        // 构造函数注入状态服务（Discord.Net会自动处理）
        public Foo(StringStateService stateService)
        {
            _stateService = stateService;
        }

        [Command("initializeString")]
        public async Task initializeString()
        {
            _stateService.InitializeUserString(Context.User.Id);
            await ReplyAsync("你的专属字符串已初始化！");
        }

        [Command("addToString")]
        public async Task addToString([Remainder]string s)
        {
            bool success = _stateService.AppendToUserString(Context.User.Id, s);
            if (!success)
            {
                await ReplyAsync("请先使用!initializeString初始化你的字符串！");
                return;
            }
            await ReplyAsync("已添加内容到你的专属字符串！");
        }

        [Command("printString")]
        public async Task printString()
        {
            string str = _stateService.GetUserString(Context.User.Id);
            await ReplyAsync(str ?? "你的专属字符串未初始化！");
        }
    }
}

这个方案的优势是：状态持久保存在内存中，支持用户/服务器级别的数据隔离，且天生支持多并发（因为用了线程安全的字典）。

方案3：内存缓存（适合临时状态） #

如果你的字符串不需要永久保存，只是临时存在一段时间（比如1小时后自动过期），可以用IMemoryCache来实现：

第一步：注册缓存服务 #

services.AddMemoryCache();

第二步：在模块中使用缓存 #

using Discord.Commands;
using System.Threading.Tasks;
using Microsoft.Extensions.Caching.Memory;

namespace UsefulDiscordBot.Modules
{
    public class Foo : ModuleBase<SocketCommandContext>
    {
        private readonly IMemoryCache _cache;
        // 缓存键前缀，避免和其他缓存数据冲突
        private readonly string _cacheKeyPrefix = "UserString_";

        public Foo(IMemoryCache cache)
        {
            _cache = cache;
        }

        [Command("initializeString")]
        public async Task initializeString()
        {
            string cacheKey = $"{_cacheKeyPrefix}{Context.User.Id}";
            // 设置缓存，1小时后自动过期
            _cache.Set(cacheKey, "Initialized", TimeSpan.FromHours(1));
            await ReplyAsync("字符串已初始化，1小时后自动过期！");
        }

        [Command("addToString")]
        public async Task addToString([Remainder]string s)
        {
            string cacheKey = $"{_cacheKeyPrefix}{Context.User.Id}";
            if (!_cache.TryGetValue(cacheKey, out string currentStr))
            {
                await ReplyAsync("请先初始化字符串！");
                return;
            }
            currentStr += s;
            // 更新缓存，重置过期时间
            _cache.Set(cacheKey, currentStr, TimeSpan.FromHours(1));
            await ReplyAsync("已添加内容！");
        }

        [Command("printString")]
        public async Task printString()
        {
            string cacheKey = $"{_cacheKeyPrefix}{Context.User.Id}";
            _cache.TryGetValue(cacheKey, out string str);
            await ReplyAsync(str ?? "字符串未初始化或已过期！");
        }
    }
}

这个方案适合临时数据，不用手动管理内存，缓存会自动清理过期数据。

内容的提问来源于stack exchange，提问作者piper2200s