C#多程序实例共享字典变量的实现方案咨询

以下是几种无需额外数据库、可实现多进程共享已加载字典的可行方案：

1. 内存映射文件（Memory-Mapped Files） #

直接将序列化后的字典数据写入共享内存区域，所有进程通过映射这块内存来读取字典，避免重复加载文件和内存冗余。

实现步骤： #

• 首个进程负责加载字典，将其序列化为二进制数据后写入内存映射文件。
• 后续进程打开同一个内存映射文件，读取二进制数据反序列化为本地字典实例。

代码示例： #

写入共享内存（首个进程）

// 加载你的字典数据
var searchTable = LoadSearchTableFromLargeFile();
var searchPersonTable = LoadSearchPersonTableFromLargeFile();

// 创建或打开内存映射文件（预估足够容纳两个字典的大小）
using var mmf = MemoryMappedFile.CreateOrOpen("SharedSearchTables", 500 * 1024 * 1024);
using var stream = mmf.CreateViewStream();

// 用Protobuf.NET序列化（比BinaryFormatter更安全高效，需安装NuGet包：protobuf-net）
Serializer.Serialize(stream, searchTable);
Serializer.Serialize(stream, searchPersonTable);

读取共享内存（其他进程）

// 打开已存在的内存映射文件
using var mmf = MemoryMappedFile.OpenExisting("SharedSearchTables");
using var stream = mmf.CreateViewStream();

// 反序列化为字典
var searchTable = Serializer.Deserialize<Dictionary<string, (char, char)>>(stream);
var searchPersonTable = Serializer.Deserialize<Dictionary<string, Person>>(stream);

注意事项： #

• 优先选择安全高效的序列化库（如Protobuf.NET、MessagePack）替代BinaryFormatter（存在安全风险）。
• 需提前预估内存映射文件的大小，避免因数据过大导致写入失败。

2. 独立服务进程（单例） #

专门启动一个进程负责加载并持有字典，其他处理文件的进程通过进程间通信（IPC）向该服务进程发起查询，无需自行加载字典。

可选IPC方式： #

• 命名管道：轻量高效，适合本地进程通信。
• gRPC：现代跨平台RPC框架，性能优异，扩展性强。

命名管道实现示例： #

服务端（持有字典的进程）

// 预加载字典
var searchTable = LoadSearchTableFromLargeFile();
var searchPersonTable = LoadSearchPersonTableFromLargeFile();

// 启动命名管道监听
while (true)
{
    using var pipeServer = new NamedPipeServerStream("SearchTableService", PipeDirection.InOut);
    pipeServer.WaitForConnection();

    try
    {
        using var reader = new StreamReader(pipeServer);
        using var writer = new StreamWriter(pipeServer);
        pipeServer.ReadMode = PipeTransmissionMode.Message;

        var request = reader.ReadLine();
        if (string.IsNullOrEmpty(request)) continue;

        // 处理searchTable查询
        if (request.StartsWith("SEARCH:"))
        {
            var key = request.Substring(7);
            if (searchTable.TryGetValue(key, out var value))
            {
                writer.WriteLine($"{value.Item1}|{value.Item2}");
            }
            else
            {
                writer.WriteLine("NOT_FOUND");
            }
        }
        // 处理searchPersonTable查询
        else if (request.StartsWith("PERSON:"))
        {
            var key = request.Substring(7);
            if (searchPersonTable.TryGetValue(key, out var person))
            {
                writer.WriteLine(JsonSerializer.Serialize(person));
            }
            else
            {
                writer.WriteLine("NOT_FOUND");
            }
        }
        writer.Flush();
    }
    catch (Exception ex)
    {
        // 处理连接异常
        Console.WriteLine($"Connection error: {ex.Message}");
    }
}

客户端（处理文件的进程）

// 查询searchTable的示例
using var pipeClient = new NamedPipeClientStream(".", "SearchTableService", PipeDirection.InOut);
pipeClient.Connect(1000);

using var reader = new StreamReader(pipeClient);
using var writer = new StreamWriter(pipeClient);
pipeClient.ReadMode = PipeTransmissionMode.Message;

// 发送查询请求
writer.WriteLine("SEARCH:targetKey");
writer.Flush();

// 获取结果
var response = reader.ReadLine();
if (response != "NOT_FOUND")
{
    var parts = response.Split('|');
    var result = (parts[0][0], parts[1][0]);
    // 使用查询结果处理文件
}

优点： #

• 字典仅在服务进程中加载一次，内存占用最小。
• 可统一管理字典的更新逻辑（若后续有需求）。

3. 共享内存+自定义非托管结构（进阶） #

如果序列化反序列化开销过大，可将字典数据转换为非托管结构体直接存储在共享内存中，进程直接访问内存地址查询数据，无需反序列化整个字典。

核心思路： #

• 定义与字典条目对应的非托管结构体（固定内存布局）。
• 首个进程将字典数据写入共享内存的结构体数组，并构建哈希索引（存储键的哈希值与条目位置的映射）。
• 其他进程通过哈希索引直接在共享内存中查找目标条目。

注意事项： #

• 需处理并发访问的线程安全问题（如使用Mutex互斥锁）。
• 实现复杂度较高，适合性能要求极高的场景。

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