EventWaitHandle Sınıf

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Threading.dll

Kaynak:

EventWaitHandle.cs

İş parçacığı eşitleme olayını temsil eder.

public ref class EventWaitHandle : System::Threading::WaitHandle

public class EventWaitHandle : System.Threading.WaitHandle

type EventWaitHandle = class
    inherit WaitHandle

Public Class EventWaitHandle
Inherits WaitHandle

Devralma

Object

MarshalByRefObject

WaitHandle

EventWaitHandle

Türetilmiş

System.Threading.AutoResetEvent

System.Threading.ManualResetEvent

Örnekler

Aşağıdaki kod örneği, ana iş parçacığının SignalAndWait(WaitHandle, WaitHandle) engellenen bir iş parçacığına sinyal göndermesine ve ardından iş parçacığının görevi bitirmesini beklemesine izin vermek için yöntem aşırı yüklemesini kullanır.

Örnek beş iş parçacığı başlatır ve bayrağıyla oluşturulan bir EventWaitHandle iş parçacığını EventResetMode.AutoReset engellemelerine olanak tanır, ardından kullanıcı Enter tuşuna her bastığında bir iş parçacığı serbest bırakır. Örnek daha sonra beş iş parçacığını daha kuyruğa alır ve bayrağıyla EventWaitHandle oluşturulan bir EventResetMode.ManualReset kullanarak bunların tümünü serbest bırakır.

using System;
using System.Threading;

public class Example
{
    // The EventWaitHandle used to demonstrate the difference
    // between AutoReset and ManualReset synchronization events.
    //
    private static EventWaitHandle ewh;

    // A counter to make sure all threads are started and
    // blocked before any are released. A Long is used to show
    // the use of the 64-bit Interlocked methods.
    //
    private static long threadCount = 0;

    // An AutoReset event that allows the main thread to block
    // until an exiting thread has decremented the count.
    //
    private static EventWaitHandle clearCount = 
        new EventWaitHandle(false, EventResetMode.AutoReset);

    [MTAThread]
    public static void Main()
    {
        // Create an AutoReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.AutoReset);

        // Create and start five numbered threads. Use the
        // ParameterizedThreadStart delegate, so the thread
        // number can be passed as an argument to the Start 
        // method.
        for (int i = 0; i <= 4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        // When multiple threads use a 64-bit value on a 32-bit
        // system, you must access the value through the
        // Interlocked class to guarantee thread safety.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Release one thread each time the user presses ENTER,
        // until all threads have been released.
        //
        while (Interlocked.Read(ref threadCount) > 0)
        {
            Console.WriteLine("Press ENTER to release a waiting thread.");
            Console.ReadLine();

            // SignalAndWait signals the EventWaitHandle, which
            // releases exactly one thread before resetting, 
            // because it was created with AutoReset mode. 
            // SignalAndWait then blocks on clearCount, to 
            // allow the signaled thread to decrement the count
            // before looping again.
            //
            WaitHandle.SignalAndWait(ewh, clearCount);
        }
        Console.WriteLine();

        // Create a ManualReset EventWaitHandle.
        //
        ewh = new EventWaitHandle(false, EventResetMode.ManualReset);

        // Create and start five more numbered threads.
        //
        for(int i=0; i<=4; i++)
        {
            Thread t = new Thread(
                new ParameterizedThreadStart(ThreadProc)
            );
            t.Start(i);
        }

        // Wait until all the threads have started and blocked.
        //
        while (Interlocked.Read(ref threadCount) < 5)
        {
            Thread.Sleep(500);
        }

        // Because the EventWaitHandle was created with
        // ManualReset mode, signaling it releases all the
        // waiting threads.
        //
        Console.WriteLine("Press ENTER to release the waiting threads.");
        Console.ReadLine();
        ewh.Set();
    }

    public static void ThreadProc(object data)
    {
        int index = (int) data;

        Console.WriteLine("Thread {0} blocks.", data);
        // Increment the count of blocked threads.
        Interlocked.Increment(ref threadCount);

        // Wait on the EventWaitHandle.
        ewh.WaitOne();

        Console.WriteLine("Thread {0} exits.", data);
        // Decrement the count of blocked threads.
        Interlocked.Decrement(ref threadCount);

        // After signaling ewh, the main thread blocks on
        // clearCount until the signaled thread has 
        // decremented the count. Signal it now.
        //
        clearCount.Set();
    }
}

Imports System.Threading

Public Class Example

    ' The EventWaitHandle used to demonstrate the difference
    ' between AutoReset and ManualReset synchronization events.
    '
    Private Shared ewh As EventWaitHandle

    ' A counter to make sure all threads are started and
    ' blocked before any are released. A Long is used to show
    ' the use of the 64-bit Interlocked methods.
    '
    Private Shared threadCount As Long = 0

    ' An AutoReset event that allows the main thread to block
    ' until an exiting thread has decremented the count.
    '
    Private Shared clearCount As New EventWaitHandle(False, _
        EventResetMode.AutoReset)

    <MTAThread> _
    Public Shared Sub Main()

        ' Create an AutoReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.AutoReset)

        ' Create and start five numbered threads. Use the
        ' ParameterizedThreadStart delegate, so the thread
        ' number can be passed as an argument to the Start 
        ' method.
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        ' When multiple threads use a 64-bit value on a 32-bit
        ' system, you must access the value through the
        ' Interlocked class to guarantee thread safety.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Release one thread each time the user presses ENTER,
        ' until all threads have been released.
        '
        While Interlocked.Read(threadCount) > 0
            Console.WriteLine("Press ENTER to release a waiting thread.")
            Console.ReadLine()

            ' SignalAndWait signals the EventWaitHandle, which
            ' releases exactly one thread before resetting, 
            ' because it was created with AutoReset mode. 
            ' SignalAndWait then blocks on clearCount, to 
            ' allow the signaled thread to decrement the count
            ' before looping again.
            '
            WaitHandle.SignalAndWait(ewh, clearCount)
        End While
        Console.WriteLine()

        ' Create a ManualReset EventWaitHandle.
        '
        ewh = New EventWaitHandle(False, EventResetMode.ManualReset)

        ' Create and start five more numbered threads.
        '
        For i As Integer = 0 To 4
            Dim t As New Thread(AddressOf ThreadProc)
            t.Start(i)
        Next i

        ' Wait until all the threads have started and blocked.
        '
        While Interlocked.Read(threadCount) < 5
            Thread.Sleep(500)
        End While

        ' Because the EventWaitHandle was created with
        ' ManualReset mode, signaling it releases all the
        ' waiting threads.
        '
        Console.WriteLine("Press ENTER to release the waiting threads.")
        Console.ReadLine()
        ewh.Set()
        
    End Sub

    Public Shared Sub ThreadProc(ByVal data As Object)
        Dim index As Integer = CInt(data)

        Console.WriteLine("Thread {0} blocks.", data)
        ' Increment the count of blocked threads.
        Interlocked.Increment(threadCount)

        ' Wait on the EventWaitHandle.
        ewh.WaitOne()

        Console.WriteLine("Thread {0} exits.", data)
        ' Decrement the count of blocked threads.
        Interlocked.Decrement(threadCount)

        ' After signaling ewh, the main thread blocks on
        ' clearCount until the signaled thread has 
        ' decremented the count. Signal it now.
        '
        clearCount.Set()
    End Sub
End Class

Açıklamalar

sınıfı, EventWaitHandle iş parçacıklarının sinyal göndererek birbirleriyle iletişim kurmasını sağlar. Genellikle, engellenmemiş bir iş parçacığı yöntemini çağırana EventWaitHandle kadar bir Set veya daha fazla iş parçacığı engellenen iş parçacıklarından birini veya daha fazlasını serbest bırakarak bir üzerinde engeller. bir iş parçacığı EventWaitHandle sinyal verebilir ve ardından static (Visual Basic'da Shared) WaitHandle.SignalAndWait yöntemini çağırarak bunu engelleyebilir.

Note

sınıfı, EventWaitHandle adlandırılmış sistem eşitleme olaylarına erişim sağlar.

Sinyal verilmiş bir EventWaitHandle kullanıcının davranışı, sıfırlama moduna bağlıdır. Bayrağıyla EventWaitHandle oluşturulan birEventResetMode.AutoReset, tek bir bekleyen iş parçacığı serbest bırakıldıktan sonra sinyal gönderildiğinde otomatik olarak sıfırlanır. EventWaitHandle ile EventResetMode.ManualReset bayrağı kullanılarak oluşturulan, Reset yöntemi çağrılana kadar sinyalli olarak kalır.

Otomatik sıfırlama olayları bir kaynağa özel erişim sağlar. Hiçbir iş parçacığı beklemediğinde otomatik sıfırlama olayına işaret edilirse, bir iş parçacığı beklemeye çalışılana kadar sinyalli kalır. Olay, iş parçacığını serbest bırakır, hemen yeniden ayarlanır ve sonraki iş parçacıklarını engeller.

El ile sıfırlama olayları geçit gibidir. Olay sinyal verilmediğinde, bekleyen iş parçacıkları engellenir. Olay sinyallendiğinde, tüm bekleyen iş parçacıkları serbest bırakılır ve yöntemi çağrılana kadar Reset olay sinyalli kalır (yani sonraki beklemeler engellenmez). Diğer iş parçacıkları devam etmeden önce bir iş parçacığının bir etkinliği tamamlaması gerektiğinde el ile sıfırlama olayları yararlıdır.

EventWaitHandle nesneleri static(Shared Visual Basic) WaitHandle.WaitAll ve WaitHandle.WaitAny yöntemleriyle kullanılabilir.

Daha fazla bilgi için Eşitleme temel bilgilerine genel bakış makalesinin İş parçacığı etkileşimi veya sinyal oluşturma bölümüne bakın.

Caution

Varsayılan olarak, adlandırılmış bir olay onu oluşturan kullanıcıyla sınırlı değildir. Diğer kullanıcılar, olayı uygunsuz bir şekilde ayarlayarak veya sıfırlayarak müdahale etmek de dahil olmak üzere olayı açabilir ve kullanabilir. Erişimi belirli kullanıcılarla kısıtlamak için bir oluşturucu aşırı yüklemesi kullanabilir veya EventWaitHandleAcl adlandırılmış olayı oluştururken bir EventWaitHandleSecurity geçirebilirsiniz. Güvenilmeyen kullanıcıların kod çalıştırabileceği sistemlerde erişim kısıtlamaları olmadan adlandırılmış olayları kullanmaktan kaçının.

Oluşturucular

Name	Description
EventWaitHandle(Boolean, EventResetMode, String, Boolean)	Bu çağrının sonucu olarak oluşturulursa bekleme tutamacının EventWaitHandle başlangıçta sinyal verilip verilmeyeceğini, otomatik olarak mı yoksa el ile mi sıfırlandığını, sistem eşitleme olayının adını ve çağrıdan sonraki değeri adlandırılmış sistem olayının oluşturulup oluşturulmadığını gösteren boole değişkeni belirterek sınıfın yeni bir örneğini başlatır.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions, Boolean)	Bu çağrının sonucu olarak oluşturulursa bekleme tutamacının EventWaitHandle başlangıçta sinyal verilip verilmeyeceğini, otomatik olarak mı yoksa el ile mi sıfırlandığını, sistem eşitleme olayının adını, kullanıcı kapsamı ve oturum kapsamı erişimini ayarlama seçeneklerini ve çağrıdan sonraki değeri adlandırılmış sistem olayının oluşturulup oluşturulmadığını gösteren bir Boole değişkeni belirterek sınıfın yeni bir örneğini başlatır.
EventWaitHandle(Boolean, EventResetMode, String, NamedWaitHandleOptions)	Bu çağrının sonucu olarak oluşturulursa bekleme tutamacının EventWaitHandle başlangıçta sinyal verilip verilmeyeceğini, otomatik olarak mı yoksa el ile mi sıfırlandığını, sistem eşitleme olayının adını ve kullanıcı kapsamı ve oturum kapsamı erişimini ayarlama seçeneklerini belirterek sınıfın yeni bir örneğini başlatır.
EventWaitHandle(Boolean, EventResetMode, String)	Bu çağrının sonucu olarak oluşturulursa bekleme tutamacının EventWaitHandle başlangıçta işaretlenip işaretlenmediğini, otomatik olarak mı yoksa el ile mi sıfırlanıp sıfırlanmayacağını ve sistem eşitleme olayının adını belirterek sınıfın yeni bir örneğini başlatır.
EventWaitHandle(Boolean, EventResetMode)	Bekleme tutamacının EventWaitHandle başlangıçta işaretlenip işaretlenmediğini ve otomatik olarak mı yoksa el ile mi sıfırlanıp sıfırlanmayacağını belirterek sınıfın yeni bir örneğini başlatır.

Alanlar

Name	Description
WaitTimeout	Bekleme tutamaçlarından herhangi biri işaretlenmeden önce bir WaitAny(WaitHandle[], Int32, Boolean) işlemin zaman aşımına uğramasını gösterir. Bu alan sabittir. (Devralındığı yer: WaitHandle)

Özellikler

Name	Description
Handle	Geçersiz. Yerel işletim sistemi tutamacını alır veya ayarlar. (Devralındığı yer: WaitHandle)
SafeWaitHandle	Yerel işletim sistemi tutamacını alır veya ayarlar. (Devralındığı yer: WaitHandle)

Yöntemler

Name	Description
Close()	Geçerli WaitHandletarafından tutulan tüm kaynakları serbest bırakır. (Devralındığı yer: WaitHandle)
Dispose()	Sınıfın geçerli örneği WaitHandle tarafından kullanılan tüm kaynakları serbest bırakır. (Devralındığı yer: WaitHandle)
Dispose(Boolean)	Türetilmiş bir sınıfta geçersiz kılındığında, tarafından WaitHandlekullanılan yönetilmeyen kaynakları serbest bırakır ve isteğe bağlı olarak yönetilen kaynakları serbest bırakır. (Devralındığı yer: WaitHandle)
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLifetimeService()	Geçersiz. Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetType()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
InitializeLifetimeService()	Geçersiz. Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnesinin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
OpenExisting(String, NamedWaitHandleOptions)	Zaten varsa belirtilen adlandırılmış eşitleme olayını açar. Seçenekler yalnızca geçerli kullanıcıya ayarlanırsa, nesnenin erişim denetimleri çağıran kullanıcı için doğrulanır.
OpenExisting(String)	Zaten varsa belirtilen adlandırılmış eşitleme olayını açar.
Reset()	Olayın durumunu işaretsiz olarak ayarlar ve iş parçacıklarının engellenmesine neden olur.
Set()	Bir veya daha fazla bekleyen iş parçacığının devam etmelerine olanak tanıyarak olayın durumunu işaretlendi olarak ayarlar.
ToString()	Geçerli nesneyi temsil eden bir dize döndürür. (Devralındığı yer: Object)
TryOpenExisting(String, EventWaitHandle)	Belirtilen adlandırılmış eşitleme olayını (zaten varsa) açar ve işlemin başarılı olup olmadığını gösteren bir değer döndürür.
TryOpenExisting(String, NamedWaitHandleOptions, EventWaitHandle)	Belirtilen adlandırılmış eşitleme olayını (zaten varsa) açar ve işlemin başarılı olup olmadığını gösteren bir değer döndürür. Seçenekler yalnızca geçerli kullanıcıya ayarlanırsa, nesnenin erişim denetimleri çağıran kullanıcı için doğrulanır.
WaitOne()	Geçerli iş parçacığını, geçerli WaitHandle bir sinyal alıncaya kadar engeller. (Devralındığı yer: WaitHandle)
WaitOne(Int32, Boolean)	Geçerli iş parçacığını, zaman aralığını belirtmek ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtmek için 32 bit imzalı bir tamsayı kullanarak bir WaitHandle sinyal alana kadar geçerli iş parçacığını engeller. (Devralındığı yer: WaitHandle)
WaitOne(Int32)	Geçerli iş parçacığını, milisaniye cinsinden zaman aralığını belirtmek için 32 bit imzalı bir tamsayı kullanarak, geçerli WaitHandle iş parçacığını bir sinyal alana kadar engeller. (Devralındığı yer: WaitHandle)
WaitOne(TimeSpan, Boolean)	Geçerli örnek bir sinyal alana kadar geçerli iş parçacığını engeller; zaman aralığını belirtmek için kullanarak TimeSpan ve beklemeden önce eşitleme etki alanından çıkılıp çıkılmayacağını belirtir. (Devralındığı yer: WaitHandle)
WaitOne(TimeSpan)	Geçerli örnek bir sinyal alana kadar geçerli iş parçacığını engeller ve zaman aralığını belirtmek için bir TimeSpan kullanılır. (Devralındığı yer: WaitHandle)

Uzantı Metotları

Name	Description
GetAccessControl(EventWaitHandle)	Belirtilen handleiçin güvenlik tanımlayıcılarını döndürür.
GetSafeWaitHandle(WaitHandle)	Yerel işletim sistemi bekleme tutamacını güvenli tutamacını alır.
SetAccessControl(EventWaitHandle, EventWaitHandleSecurity)	Belirtilen olay bekleme tanıtıcısı için güvenlik tanımlayıcılarını ayarlar.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Yerel işletim sistemi bekleme tutamacı için güvenli bir tanıtıcı ayarlar.

İş Parçacığı Güvenliği

Bu tür iş parçacığı güvenlidir.

Ayrıca bkz.

• WaitHandle
• AutoResetEvent
• ManualResetEvent
• Yönetilen İş Parçacıkları
• Eşitleme temel bilgilerine genel bakış