WaitHandle Sınıf

Tanım

Paylaşılan kaynaklara özel erişimi bekleyen işletim sistemine özgü nesneleri kapsüller.Encapsulates operating system-specific objects that wait for exclusive access to shared resources.

public ref class WaitHandle abstract : IDisposable
public ref class WaitHandle abstract : MarshalByRefObject, IDisposable
public abstract class WaitHandle : IDisposable
public abstract class WaitHandle : MarshalByRefObject, IDisposable
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class WaitHandle : MarshalByRefObject, IDisposable
type WaitHandle = class
    interface IDisposable
type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable
[<System.Runtime.InteropServices.ComVisible(true)>]
type WaitHandle = class
    inherit MarshalByRefObject
    interface IDisposable
Public MustInherit Class WaitHandle
Implements IDisposable
Public MustInherit Class WaitHandle
Inherits MarshalByRefObject
Implements IDisposable
Devralma
WaitHandle
Devralma
Türetilmiş
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki kod örneği, ana iş parçacığı, sınıfın statik ve yöntemlerini kullanarak görevlerinin tamamlanmasını beklerken iki iş parçacığının arka plan görevleri nasıl yapabileceği WaitAny gösterilmektedir WaitAll WaitHandle .The following code example shows how two threads can do background tasks while the Main thread waits for the tasks to complete using the static WaitAny and WaitAll methods of the WaitHandle class.

using namespace System;
using namespace System::Threading;

public ref class WaitHandleExample
{
    // Define a random number generator for testing.
private:
    static Random^ random = gcnew Random();
public:
    static void DoTask(Object^ state)
    {
        AutoResetEvent^ autoReset = (AutoResetEvent^) state;
        int time = 1000 * random->Next(2, 10);
        Console::WriteLine("Performing a task for {0} milliseconds.", time);
        Thread::Sleep(time);
        autoReset->Set();
    }
};

int main()
{
    // Define an array with two AutoResetEvent WaitHandles.
    array<WaitHandle^>^ handles = gcnew array<WaitHandle^> {
        gcnew AutoResetEvent(false), gcnew AutoResetEvent(false)};

    // Queue up two tasks on two different threads;
    // wait until all tasks are completed.
    DateTime timeInstance = DateTime::Now;
    Console::WriteLine("Main thread is waiting for BOTH tasks to " +
        "complete.");
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[0]);
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[1]);
    WaitHandle::WaitAll(handles);
    // The time shown below should match the longest task.
    Console::WriteLine("Both tasks are completed (time waited={0})",
        (DateTime::Now - timeInstance).TotalMilliseconds);

    // Queue up two tasks on two different threads;
    // wait until any tasks are completed.
    timeInstance = DateTime::Now;
    Console::WriteLine();
    Console::WriteLine("The main thread is waiting for either task to " +
        "complete.");
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[0]);
    ThreadPool::QueueUserWorkItem(
        gcnew WaitCallback(WaitHandleExample::DoTask), handles[1]);
    int index = WaitHandle::WaitAny(handles);
    // The time shown below should match the shortest task.
    Console::WriteLine("Task {0} finished first (time waited={1}).",
        index + 1, (DateTime::Now - timeInstance).TotalMilliseconds);
}

// This code produces the following sample output.
//
// Main thread is waiting for BOTH tasks to complete.
// Performing a task for 7000 milliseconds.
// Performing a task for 4000 milliseconds.
// Both tasks are completed (time waited=7064.8052)

// The main thread is waiting for either task to complete.
// Performing a task for 2000 milliseconds.
// Performing a task for 2000 milliseconds.
// Task 1 finished first (time waited=2000.6528).
using System;
using System.Threading;

public sealed class App
{
    // Define an array with two AutoResetEvent WaitHandles.
    static WaitHandle[] waitHandles = new WaitHandle[]
    {
        new AutoResetEvent(false),
        new AutoResetEvent(false)
    };

    // Define a random number generator for testing.
    static Random r = new Random();

    static void Main()
    {
        // Queue up two tasks on two different threads;
        // wait until all tasks are completed.
        DateTime dt = DateTime.Now;
        Console.WriteLine("Main thread is waiting for BOTH tasks to complete.");
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[0]);
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[1]);
        WaitHandle.WaitAll(waitHandles);
        // The time shown below should match the longest task.
        Console.WriteLine("Both tasks are completed (time waited={0})",
            (DateTime.Now - dt).TotalMilliseconds);

        // Queue up two tasks on two different threads;
        // wait until any tasks are completed.
        dt = DateTime.Now;
        Console.WriteLine();
        Console.WriteLine("The main thread is waiting for either task to complete.");
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[0]);
        ThreadPool.QueueUserWorkItem(new WaitCallback(DoTask), waitHandles[1]);
        int index = WaitHandle.WaitAny(waitHandles);
        // The time shown below should match the shortest task.
        Console.WriteLine("Task {0} finished first (time waited={1}).",
            index + 1, (DateTime.Now - dt).TotalMilliseconds);
    }

    static void DoTask(Object state)
    {
        AutoResetEvent are = (AutoResetEvent) state;
        int time = 1000 * r.Next(2, 10);
        Console.WriteLine("Performing a task for {0} milliseconds.", time);
        Thread.Sleep(time);
        are.Set();
    }
}

// This code produces output similar to the following:
//
//  Main thread is waiting for BOTH tasks to complete.
//  Performing a task for 7000 milliseconds.
//  Performing a task for 4000 milliseconds.
//  Both tasks are completed (time waited=7064.8052)
//
//  The main thread is waiting for either task to complete.
//  Performing a task for 2000 milliseconds.
//  Performing a task for 2000 milliseconds.
//  Task 1 finished first (time waited=2000.6528).
Imports System.Threading

NotInheritable Public Class App
    ' Define an array with two AutoResetEvent WaitHandles.
    Private Shared waitHandles() As WaitHandle = _
        {New AutoResetEvent(False), New AutoResetEvent(False)}
    
    ' Define a random number generator for testing.
    Private Shared r As New Random()
    
    <MTAThreadAttribute> _
    Public Shared Sub Main() 
        ' Queue two tasks on two different threads; 
        ' wait until all tasks are completed.
        Dim dt As DateTime = DateTime.Now
        Console.WriteLine("Main thread is waiting for BOTH tasks to complete.")
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(0))
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(1))
        WaitHandle.WaitAll(waitHandles)
        ' The time shown below should match the longest task.
        Console.WriteLine("Both tasks are completed (time waited={0})", _
            (DateTime.Now - dt).TotalMilliseconds)
        
        ' Queue up two tasks on two different threads; 
        ' wait until any tasks are completed.
        dt = DateTime.Now
        Console.WriteLine()
        Console.WriteLine("The main thread is waiting for either task to complete.")
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(0))
        ThreadPool.QueueUserWorkItem(AddressOf DoTask, waitHandles(1))
        Dim index As Integer = WaitHandle.WaitAny(waitHandles)
        ' The time shown below should match the shortest task.
        Console.WriteLine("Task {0} finished first (time waited={1}).", _
            index + 1,(DateTime.Now - dt).TotalMilliseconds)
    
    End Sub
    
    Shared Sub DoTask(ByVal state As [Object]) 
        Dim are As AutoResetEvent = CType(state, AutoResetEvent)
        Dim time As Integer = 1000 * r.Next(2, 10)
        Console.WriteLine("Performing a task for {0} milliseconds.", time)
        Thread.Sleep(time)
        are.Set()
    
    End Sub
End Class

' This code produces output similar to the following:
'
'  Main thread is waiting for BOTH tasks to complete.
'  Performing a task for 7000 milliseconds.
'  Performing a task for 4000 milliseconds.
'  Both tasks are completed (time waited=7064.8052)
' 
'  The main thread is waiting for either task to complete.
'  Performing a task for 2000 milliseconds.
'  Performing a task for 2000 milliseconds.
'  Task 1 finished first (time waited=2000.6528).

Açıklamalar

WaitHandleSınıfı yerel bir işletim sistemi eşitleme tanıtıcısını kapsüller ve çalışma zamanında birden çok bekleme işlemine izin veren tüm eşitleme nesnelerini temsil etmek için kullanılır.The WaitHandle class encapsulates a native operating system synchronization handle and is used to represent all synchronization objects in the runtime that allow multiple wait operations. Diğer eşitleme nesnelerine sahip Bekleme tutamaçlarının bir karşılaştırması için bkz. eşitleme temelleri 'Ne genel bakış.For a comparison of wait handles with other synchronization objects, see Overview of Synchronization Primitives.

WaitHandleSınıfın kendisi soyuttur.The WaitHandle class itself is abstract. Türetilmiş sınıflar WaitHandle , paylaşılan bir kaynağa erişim almayı veya serbest bırakmayı göstermek için bir sinyal mekanizması tanımlayın, ancak WaitHandle paylaşılan kaynaklara erişim beklerken engellemek için devralınmış yöntemleri kullanırlar.Classes derived from WaitHandle define a signaling mechanism to indicate taking or releasing access to a shared resource, but they use the inherited WaitHandle methods to block while waiting for access to shared resources. Öğesinden türetilen sınıflar WaitHandle şunlardır:The classes derived from WaitHandle include:

İş parçacıkları WaitOne , öğesinden türetilmiş sınıflar tarafından devralınan örnek yöntemini çağırarak tek bir bekleme tutamacını engelleyebilir WaitHandle .Threads can block on an individual wait handle by calling the instance method WaitOne, which is inherited by classes derived from WaitHandle.

Türetilmiş sınıfları WaitHandle iş parçacığı benzeşimine göre farklılık gösterir.The derived classes of WaitHandle differ in their thread affinity. Olay bekleme tutamaçları ( EventWaitHandle , AutoResetEvent , ve ManualResetEvent ) ve semaforların iş parçacığı benzeşimi yoktur; herhangi bir iş parçacığı bir olay bekleme işleyicisine veya semafora işaret edebilir.Event wait handles (EventWaitHandle, AutoResetEvent, and ManualResetEvent) and semaphores do not have thread affinity; any thread can signal an event wait handle or semaphore. Birbirini kapsamayan, diğer yandan iş parçacığı benzeşimine sahiptir; bir mutex sahibi olan iş parçacığı onu serbest bırakmalıdır ve bir iş parçacığı ReleaseMutex yöntemi, sahip olmadığı bir mutex üzerinde çağırırsa bir özel durum oluşur.Mutexes, on the other hand, do have thread affinity; the thread that owns a mutex must release it, and an exception is thrown if a thread calls the ReleaseMutex method on a mutex that it does not own.

WaitHandleSınıfı öğesinden türetildiğinden MarshalByRefObject , bu sınıflar uygulama etki alanı sınırları genelinde iş parçacığı etkinliklerini eşitlemeye yönelik olarak kullanılabilir.Because the WaitHandle class derives from MarshalByRefObject, these classes can be used to synchronize the activities of threads across application domain boundaries.

Türetilmiş sınıflarının yanı sıra, WaitHandle bir veya daha fazla eşitleme nesnesi bir sinyal alıncaya kadar bir iş parçacığını engelleyen birkaç statik yöntem vardır.In addition to its derived classes, the WaitHandle class has a number of static methods that block a thread until one or more synchronization objects receive a signal. Bu modüller şunlardır:These include:

  • SignalAndWait, bir iş parçacığının bir bekleme tutamacına işaret etmesine ve bir diğerinin anında beklemesine izin verir.SignalAndWait, which allows a thread to signal one wait handle and immediately wait on another.

  • WaitAll, bir dizideki tüm bekleme tanıtıcıları bir sinyal alıncaya kadar bir iş parçacığının beklemesini izin verir.WaitAll, which allows a thread to wait until all the wait handles in an array receive a signal.

  • WaitAny, bir iş parçacığının belirli bir bekleme tutamacı kümesinden herhangi biri için beklenene kadar beklemesini sağlar.WaitAny, which allows a thread to wait until any one of a specified set of wait handles has been signaled.

Bu yöntemlerin aşırı yüklemeleri, bekleme süresini bırakmak için zaman aşımı aralıkları ve bekleme süresi girmeden önce, diğer iş parçacıklarının eşitleme bağlamını kullanmasına olanak sağlar.The overloads of these methods provide timeout intervals for abandoning the wait, and the opportunity to exit a synchronization context before entering the wait, allowing other threads to use the synchronization context.

Önemli

Bu tür, IDisposable arabirimini uygular.This type implements the IDisposable interface. Türü veya ondan türetilmiş bir tür kullanmayı bitirdiğinizde, bunu doğrudan veya dolaylı olarak atmalısınız.When you have finished using the type or a type derived from it, you should dispose of it either directly or indirectly. Türü doğrudan atmak için, Close yöntemini bir try / catch blokta çağırın.To dispose of the type directly, call its Close method in a try/catch block. Dolaylı olarak atmak için using (C# dilinde) veya (Visual Basic) gibi bir dil yapısı kullanın Using .To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Daha fazla bilgi için, interface konusunun "IDisposable uygulayan bir nesne kullanma" bölümüne bakın IDisposable .For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

WaitHandle kalıbı uygular Dispose .WaitHandle implements the Dispose pattern. Bkz. Dispose yöntemi uygulama.See Implementing a Dispose method. ' Den türettiğinizde WaitHandle , özelliğini kullanarak SafeWaitHandle yerel işletim sistemi işleyicinizi depolayın.When you derive from WaitHandle, use the SafeWaitHandle property to store your native operating system handle. Ek yönetilmeyen kaynaklar kullanmadığınız takdirde, korunan yöntemi geçersiz kılmalısınız Dispose .You do not need to override the protected Dispose method unless you use additional unmanaged resources.

Oluşturucular

WaitHandle()

WaitHandle sınıfının yeni bir örneğini başlatır.Initializes a new instance of the WaitHandle class.

Alanlar

InvalidHandle

Geçersiz bir yerel işletim sistemi tanıtıcısını temsil eder.Represents an invalid native operating system handle. Bu alan salt okunur durumdadır.This field is read-only.

WaitTimeout

WaitAny(WaitHandle[], Int32, Boolean)Herhangi bir bekleme tanıtıcıdan önce bir işlemin zaman aşımına uğradığını gösterir.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Bu alan sabittir.This field is constant.

Özellikler

Handle
Kullanımdan kalktı.

Yerel işletim sistemi tanıtıcısını alır veya ayarlar.Gets or sets the native operating system handle.

SafeWaitHandle

Yerel işletim sistemi tanıtıcısını alır veya ayarlar.Gets or sets the native operating system handle.

Yöntemler

Close()

Geçerli tarafından tutulan tüm kaynakları serbest bırakır WaitHandle .Releases all resources held by the current WaitHandle.

CreateObjRef(Type)

Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm bilgileri içeren bir nesne oluşturur.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Devralındığı yer: MarshalByRefObject)
Dispose()

WaitHandle sınıfının geçerli örneği tarafından kullanılan tüm kaynakları serbest bırakır.Releases all resources used by the current instance of the WaitHandle class.

Dispose(Boolean)

Türetilmiş bir sınıfta geçersiz kılınırsa, tarafından kullanılan yönetilmeyen kaynakları yayınlar WaitHandle ve isteğe bağlı olarak yönetilen kaynakları serbest bırakır.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
Finalize()

Geçerli örnek tarafından tutulan kaynakları serbest bırakır.Releases the resources held by the current instance.

GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetLifetimeService()
Kullanımdan kalktı.

Bu örnek için ömür ilkesini denetleyen geçerli ömür hizmeti nesnesini alır.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Devralındığı yer: MarshalByRefObject)
GetType()

TypeGeçerli örneği alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
InitializeLifetimeService()
Kullanımdan kalktı.

Bu örnek için ömür ilkesini denetlemek üzere bir ömür hizmeti nesnesi alır.Obtains a lifetime service object to control the lifetime policy for this instance.

(Devralındığı yer: MarshalByRefObject)
MemberwiseClone()

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
MemberwiseClone(Boolean)

Geçerli nesnenin basit bir kopyasını oluşturur MarshalByRefObject .Creates a shallow copy of the current MarshalByRefObject object.

(Devralındığı yer: MarshalByRefObject)
SignalAndWait(WaitHandle, WaitHandle)

Bir tane bildirir WaitHandle ve başka bir bekler.Signals one WaitHandle and waits on another.

SignalAndWait(WaitHandle, WaitHandle, Int32, Boolean)

Tek bir WaitHandle kez bildirir ve bir zaman aşımı aralığını 32 bitlik işaretli bir tamsayı olarak belirterek ve bekleme süresini girmeden önce bağlam için eşitleme etki alanından çıkmak isteyip istemediğinizi belirterek bir süre bekler.Signals one WaitHandle and waits on another, specifying a time-out interval as a 32-bit signed integer and specifying whether to exit the synchronization domain for the context before entering the wait.

SignalAndWait(WaitHandle, WaitHandle, TimeSpan, Boolean)

Tek bir WaitHandle kez bildirir ve zaman aşımı aralığını bir olarak belirterek TimeSpan ve bekleme süresini girmeden önce bağlam için eşitleme etki alanından çıkmak isteyip istemediğinizi belirterek bir tane bekler.Signals one WaitHandle and waits on another, specifying the time-out interval as a TimeSpan and specifying whether to exit the synchronization domain for the context before entering the wait.

ToString()

Geçerli nesneyi temsil eden dizeyi döndürür.Returns a string that represents the current object.

(Devralındığı yer: Object)
WaitAll(WaitHandle[])

Belirtilen dizideki tüm öğelerin bir sinyal almasını bekler.Waits for all the elements in the specified array to receive a signal.

WaitAll(WaitHandle[], Int32)

Belirtilen dizideki tüm öğelerin bir sinyal almasını bekler ve Int32 zaman aralığını belirtmek için bir değer kullanın.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval.

WaitAll(WaitHandle[], Int32, Boolean)

Belirtilen dizideki tüm öğelerin bir sinyal almasını bekler, Int32 zaman aralığını belirtmek için bir değer kullanarak ve bekleme öncesinde eşitleme etki alanından çıkmak isteyip istemediğinizi belirtir.Waits for all the elements in the specified array to receive a signal, using an Int32 value to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitAll(WaitHandle[], TimeSpan)

Belirtilen dizideki tüm öğelerin bir sinyal almasını ve TimeSpan zaman aralığını belirtmek için bir değer kullanmasını bekler.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval.

WaitAll(WaitHandle[], TimeSpan, Boolean)

Belirtilen dizideki tüm öğelerin bir sinyal almasını, TimeSpan zaman aralığını belirtmek için bir değer kullanmasını ve bekleme öncesinde eşitleme etki alanından çıkıp çıkmayacağını belirtmeyi bekler.Waits for all the elements in the specified array to receive a signal, using a TimeSpan value to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

WaitAny(WaitHandle[])

Belirtilen dizideki öğelerin bir sinyal almasını bekler.Waits for any of the elements in the specified array to receive a signal.

WaitAny(WaitHandle[], Int32)

Belirtilen dizideki herhangi bir öğenin bir sinyal almasını bekler, zaman aralığını belirtmek için 32 bitlik işaretli bir tamsayı kullanarak.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval.

WaitAny(WaitHandle[], Int32, Boolean)

Belirtilen dizideki herhangi bir öğenin bir sinyal almasını bekler, zaman aralığını belirtmek için 32 bitlik işaretli bir tamsayı kullanarak ve bekleme öncesinde eşitleme etki alanından çıkmak isteyip istemediğinizi belirterek.Waits for any of the elements in the specified array to receive a signal, using a 32-bit signed integer to specify the time interval, and specifying whether to exit the synchronization domain before the wait.

WaitAny(WaitHandle[], TimeSpan)

Belirtilen dizideki herhangi bir öğenin bir sinyal almasını bekler, TimeSpan zaman aralığını belirtmek için bir kullanın.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval.

WaitAny(WaitHandle[], TimeSpan, Boolean)

Belirtilen dizideki herhangi bir öğeyi bir sinyal almasını bekler, TimeSpan zaman aralığını belirtmek için bir kullanarak ve bekleme öncesinde eşitleme etki alanından çıkmak isteyip istemediğinizi belirterek.Waits for any of the elements in the specified array to receive a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitOne()

Geçerli bir sinyal alana kadar geçerli iş parçacığını engeller WaitHandle .Blocks the current thread until the current WaitHandle receives a signal.

WaitOne(Int32)

Geçerli iş parçacığını, geçerli bir sinyal alana kadar engeller WaitHandle ve zaman aralığını milisaniye olarak belirtmek için 32 bitlik işaretli bir tamsayı kullanın.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

WaitOne(Int32, Boolean)

Geçerli bir sinyal alana kadar geçerli iş parçacığını engeller WaitHandle , zaman aralığını belirtmek için 32 bitlik işaretli bir tamsayı kullanarak ve bekleme öncesinde eşitleme etki alanından çıkmak isteyip istemediğinizi belirterek.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

WaitOne(TimeSpan)

Geçerli örnek bir sinyal alıncaya kadar geçerli iş parçacığını engeller ve TimeSpan zaman aralığını belirtmek için bir kullanın.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

WaitOne(TimeSpan, Boolean)

Geçerli örnek bir sinyal alana kadar geçerli iş parçacığını engeller, TimeSpan zaman aralığını belirtmek için bir kullanarak ve bekleme öncesinde eşitleme etki alanından çıkmak isteyip istemediğinizi belirterek.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

Belirtik Arabirim Kullanımları

IDisposable.Dispose()

Bu API, ürün altyapısını destekler ve doğrudan kodunuzdan kullanıma yönelik değildir.

WaitHandle tarafından kullanılan tüm kaynakları serbest bırakır.Releases all resources used by the WaitHandle.

Uzantı Metotları

GetSafeWaitHandle(WaitHandle)

Yerel bir işletim sistemi bekleme tutamacı için güvenli tanıtıcıyı alır.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Yerel işletim sistemi bekleme tutamacı için güvenli bir tanıtıcı ayarlar.Sets a safe handle for a native operating system wait handle.

Şunlara uygulanır

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

Bu güvenli iş parçacığı türüdür.This type is thread safe.