AutoResetEvent and ManualResetEvent in CSharp

Back to: C# .NET Tutorial

AutoResetEvent and ManualResetEvent are synchronization primitives in C# that facilitate inter-thread communication and coordination. This article delves into their functionalities, use cases, and differences, along with practical code examples for a comprehensive understanding of their implementation.

Understanding AutoResetEvent and ManualResetEvent in C#

AutoResetEvent and ManualResetEvent are part of the System.Threading namespace in C#. They allow threads to efficiently coordinate their actions, enabling synchronized access to shared resources and controlled thread execution based on specific signals.

Exploring AutoResetEvent

  • AutoResetEvent signals one waiting thread at a time and automatically resets after releasing a single thread.
// Example usage of AutoResetEvent
AutoResetEvent autoEvent = new AutoResetEvent(false);

// Thread 1 signals the event
autoEvent.Set();

// Thread 2 waits for the signal
autoEvent.WaitOne();

Understanding ManualResetEvent

  • ManualResetEvent signals all waiting threads and remains in a signaled state until explicitly reset.
// Example usage of ManualResetEvent
ManualResetEvent manualEvent = new ManualResetEvent(false);

// Thread 1 signals the event
manualEvent.Set();

// Thread 2 waits for the signal
manualEvent.WaitOne();

Differences between AutoResetEvent and ManualResetEvent

  • AutoResetEvent automatically resets after releasing one thread, while ManualResetEvent remains signaled until explicitly reset.
  • AutoResetEvent is useful in scenarios where a resource must be accessed by only one thread at a time, while ManualResetEvent is beneficial for scenarios where multiple threads can access a resource simultaneously based on a single signal.

Conclusion

AutoResetEvent and ManualResetEvent are valuable tools for managing thread synchronization and coordination in C#. By understanding their distinctions and practical use cases, developers can effectively control access to shared resources and ensure smooth execution of concurrent tasks in multi-threaded applications.