在C#中，当另一个方法执行时，如何锁定该方法的执行，而无需自锁？

您好，我有两种方法可以处理相同的数据。方法LoadData（）从文件加载/重新加载内存中的数据，很少调用它（仅当文件更新时）。方法GetData（）从内存获取数据，并且经常从许多不同的线程调用它

我想实现以下行为：

开始执行LoadData（）时，阻止尝试执行GetData（）的新线程，然后等待当前执行GetData（）的线程完成其执行，然后继续执行LoadData（），并在完成后取消阻止以前被阻止的线程。就这样

private Object _LoadDataLock;
public void LoadData()
     lock (_LoadDataLock) {
     {
          // (1.) Block new executions of GetData();
          // (2.) Wait threads currently executing GetData() to complete its execution.

          // (3.) Do some work ..... Loading from files.

          // (4.) Unblock blocked in (1.) threads.
     }
}

public IDictionary GetData(string key1, string key2)
{
    //Do something....
    retrn data;
}

如何使用C#实现这种行为

谢谢。 Ivan

您需要一个方法调用的环境。互斥是针对某一对象的。因此，您需要在表达式语句中使用相同的对象

x

您可以与代码块一起使用：

   lock (x)
   {
       // Your code...
   }

或者，如果不想使用代码块，可以使用：

---

这听起来像是一个很好的例子，它允许一个作者，但允许多个读者

private ReaderWriterLock _lock;

public void LoadData()
{
    _lock.AcquireWriterLock();
    try
    {
         // Do some work ..... Loading from files.
    }
    finally
    {
        _lock.ReleaseWriterLock()
    }
}

public IDictionary GetData(string key1, string key2)
{
    _lock.AcquireReaderLock();
    try
    {
        //Do something....
        return data;
    }
    finally
    {
        _lock.ReleaseReaderLock()
    }
}

---

您应该熟悉同步。仔细阅读文章的所有5个部分。尝试这种方法@Farhad Mehrad Thanke You这篇文章内容丰富。

private ReaderWriterLock _lock;

public void LoadData()
{
    _lock.AcquireWriterLock();
    try
    {
         // Do some work ..... Loading from files.
    }
    finally
    {
        _lock.ReleaseWriterLock()
    }
}

public IDictionary GetData(string key1, string key2)
{
    _lock.AcquireReaderLock();
    try
    {
        //Do something....
        return data;
    }
    finally
    {
        _lock.ReleaseReaderLock()
    }
}