主页 / 问题 / 1593869
Accepted
salo12
Asked:2024-09-15 17:11:07 +0000 UTC2024-09-15 17:11:07 +0000 UTC

异步写入文件 (c#)

  • 772

我正在编写一个 TG 机器人，有一个异步方法来处理用户消息，如果用户第一次登录该机器人，会将其 TG 帐户数据写入 .json 文件。

我怀疑可能存在同时访问一个文件的情况，当新用户同时访问bot时，分别有两个线程会尝试写入一个文件

请告诉我如何消除这种情况？

  public static async Task UpdateUserFile(string jsonPath, List<User> userList)
    {
        try
        {
            var jsonString = System.Text.Json.JsonSerializer.Serialize(userList);
            await System.IO.File.WriteAllTextAsync(jsonPath, jsonString);
        }
        catch (Exception ex)
        {
            ///...
        }
    }
c#

2 个回答

  1. 可用于SemaphoreSlim同步对资源的访问。

    例如，像这样：

    private static readonly SemaphoreSlim semaphore = new SemaphoreSlim(1, 1);

public static async Task UpdateUserFile(string jsonPath, List<User> userList)
{
    await semaphore.WaitAsync();
    
    try
    {
        var jsonString = System.Text.Json.JsonSerializer.Serialize(userList);
        System.IO.File.WriteAllTextAsync(jsonPath, jsonString);
    }
    
    catch (Exception ex)
    {
        // Обработка исключений
    }
    
    finally
    {
        semaphore.Release();
    }
}
    • 1
  2. Best Answer

    我已经回答过类似的问题了。

    我将从那里获取代码并更改它以适合您的任务：

    private static readonly ConcurrentDictionary<string, object> _locks = new ConcurrentDictionary<string, SemaphoreSlim>();

private static SemaphoreSlim GetLock(string path)
{
    SemaphoreSlim semaphore;
    while (!_locks.TryGetValue(path, out semaphore))
    {
        semaphore = new SemaphoreSlim(1);
        if (_locks.TryAdd(path, semaphore))
            break;
    }
    return semaphore;
}

public static async Task ConcurrentSaveAsync(string path, string text, CancellationToken token = CancellationToken.None)
{
    SemaphoreSlim semaphore = GetLock(path);
    await semaphore.WaitAsync(token).ConfigureAwait(false);
    try
    {
        await File.WriteAllTextAsync(path, text, token).ConfigureAwait(false);
    }
    finally
    {
        semaphore.Release();
    }
}

    事实证明，每个录制的文件都将由自己的信号量控制。因此，无需等待即可同时访问不同的文件。

    加载也是如此，否则您可能会遇到在写入时发生读取的情况：

    public static async Task<string> ConcurrentLoadAsync(string path, CancellationToken token = CancellationToken.None)
{
    SemaphoreSlim semaphore = GetLock(path);
    await semaphore.WaitAsync(token).ConfigureAwait(false);
    try
    {
        return await File.ReadAllTextAsync(path, token).ConfigureAwait(false);
    }
    finally
    {
        semaphore.Release();
    }
}

    最后是你的方法：

    public static async Task UpdateUserFile(string jsonPath, List<User> userList)
{
    try
    {
        var jsonString = System.Text.Json.JsonSerializer.Serialize(userList);
        await ConcurrentSaveAsync(jsonPath, jsonString);
    }
    catch (Exception ex)
    {
        //...
    }
}

    ConcurrentSaveAsync现在只需使用和方法写入和读取可以多线程访问的文件ConcurrentLoadAsync。

    该解决方案的唯一缺点是，如果有条件地创建无限数量的文件，则信号量将在字典中累积。在这种情况下，您需要考虑清洁它，但这项任务并不容易。如果文件数量有限，那么一切都会正常工作。

    事实上，上面的一切都是一根拐杖，尽管是一个有效的拐杖。事实上，还有一个非拐杖的解决方案——使用数据库。

    • 1

相关问题