ManualResetEventSlim Sınıf

Başvuru

Tanım

Ad Alanı:: System.Threading

Bütünleştirilmiş Kod:: System.Threading.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

İşaretlendiğinde el ile sıfırlanması gereken bir iş parçacığı eşitleme olayını temsil eder. Bu sınıf, için ManualResetEventbasit bir alternatiftir.

public ref class ManualResetEventSlim : IDisposable

public class ManualResetEventSlim : IDisposable

[System.Runtime.InteropServices.ComVisible(false)]
public class ManualResetEventSlim : IDisposable

type ManualResetEventSlim = class
    interface IDisposable

[<System.Runtime.InteropServices.ComVisible(false)>]
type ManualResetEventSlim = class
    interface IDisposable

Public Class ManualResetEventSlim
Implements IDisposable

Devralma: Object
ManualResetEventSlim

Öznitelikler: ComVisibleAttribute

Uygulamalar: IDisposable

Örnekler

Aşağıdaki örnekte, bir öğesinin nasıl kullanılacağı gösterilmektedir ManualResetEventSlim.

using System;
using System.Threading;
using System.Threading.Tasks;
class MRESDemo
{

    static void Main()
    {
        MRES_SetWaitReset();
        MRES_SpinCountWaitHandle();
    }
    // Demonstrates:
    //      ManualResetEventSlim construction
    //      ManualResetEventSlim.Wait()
    //      ManualResetEventSlim.Set()
    //      ManualResetEventSlim.Reset()
    //      ManualResetEventSlim.IsSet
    static void MRES_SetWaitReset()
    {
        ManualResetEventSlim mres1 = new ManualResetEventSlim(false); // initialize as unsignaled
        ManualResetEventSlim mres2 = new ManualResetEventSlim(false); // initialize as unsignaled
        ManualResetEventSlim mres3 = new ManualResetEventSlim(true);  // initialize as signaled

        // Start an asynchronous Task that manipulates mres3 and mres2
        var observer = Task.Factory.StartNew(() =>
        {
            mres1.Wait();
            Console.WriteLine("observer sees signaled mres1!");
            Console.WriteLine("observer resetting mres3...");
            mres3.Reset(); // should switch to unsignaled
            Console.WriteLine("observer signalling mres2");
            mres2.Set();
        });

        Console.WriteLine("main thread: mres3.IsSet = {0} (should be true)", mres3.IsSet);
        Console.WriteLine("main thread signalling mres1");
        mres1.Set(); // This will "kick off" the observer Task
        mres2.Wait(); // This won't return until observer Task has finished resetting mres3
        Console.WriteLine("main thread sees signaled mres2!");
        Console.WriteLine("main thread: mres3.IsSet = {0} (should be false)", mres3.IsSet);

        // It's good form to Dispose() a ManualResetEventSlim when you're done with it
        observer.Wait(); // make sure that this has fully completed
        mres1.Dispose();
        mres2.Dispose();
        mres3.Dispose();
    }

    // Demonstrates:
    //      ManualResetEventSlim construction w/ SpinCount
    //      ManualResetEventSlim.WaitHandle
    static void MRES_SpinCountWaitHandle()
    {
        // Construct a ManualResetEventSlim with a SpinCount of 1000
        // Higher spincount => longer time the MRES will spin-wait before taking lock
        ManualResetEventSlim mres1 = new ManualResetEventSlim(false, 1000);
        ManualResetEventSlim mres2 = new ManualResetEventSlim(false, 1000);

        Task bgTask = Task.Factory.StartNew(() =>
        {
            // Just wait a little
            Thread.Sleep(100);

            // Now signal both MRESes
            Console.WriteLine("Task signalling both MRESes");
            mres1.Set();
            mres2.Set();
        });

        // A common use of MRES.WaitHandle is to use MRES as a participant in 
        // WaitHandle.WaitAll/WaitAny.  Note that accessing MRES.WaitHandle will
        // result in the unconditional inflation of the underlying ManualResetEvent.
        WaitHandle.WaitAll(new WaitHandle[] { mres1.WaitHandle, mres2.WaitHandle });
        Console.WriteLine("WaitHandle.WaitAll(mres1.WaitHandle, mres2.WaitHandle) completed.");

        // Clean up
        bgTask.Wait();
        mres1.Dispose();
        mres2.Dispose();
    }
}

Imports System.Threading
Imports System.Threading.Tasks

Module MRESDemo

    Sub Main()

    End Sub
    ' Demonstrates:
    ' ManualResetEventSlim construction
    ' ManualResetEventSlim.Wait()
    ' ManualResetEventSlim.Set()
    ' ManualResetEventSlim.Reset()
    ' ManualResetEventSlim.IsSet
    Private Sub MRES_SetWaitReset()
        ' initialize as unsignaled
        Dim mres1 As New ManualResetEventSlim(False)
        ' initialize as unsignaled
        Dim mres2 As New ManualResetEventSlim(False)
        ' initialize as signaled
        Dim mres3 As New ManualResetEventSlim(True)

        ' Start an asynchronous Task that manipulates mres3 and mres2
        Dim observer = Task.Factory.StartNew(
            Sub()
                mres1.Wait()
                Console.WriteLine("observer sees signaled mres1!")
                Console.WriteLine("observer resetting mres3...")
                mres3.Reset()
                ' should switch to unsignaled
                Console.WriteLine("observer signalling mres2")
                mres2.[Set]()
            End Sub)

        Console.WriteLine("main thread: mres3.IsSet = {0} (should be true)", mres3.IsSet)
        Console.WriteLine("main thread signalling mres1")
        mres1.[Set]()
        ' This will "kick off" the observer Task
        mres2.Wait()
        ' This won't return until observer Task has finished resetting mres3
        Console.WriteLine("main thread sees signaled mres2!")
        Console.WriteLine("main thread: mres3.IsSet = {0} (should be false)", mres3.IsSet)

        ' make sure that observer has fully completed
        observer.Wait()
        ' It's good form to Dispose() a ManualResetEventSlim when you're done with it
        mres1.Dispose()
        mres2.Dispose()
        mres3.Dispose()
    End Sub

    ' Demonstrates:
    ' ManualResetEventSlim construction w/ SpinCount
    ' ManualResetEventSlim.WaitHandle
    Private Sub MRES_SpinCountWaitHandle()
        ' Construct a ManualResetEventSlim with a SpinCount of 1000
        ' Higher spincount => longer time the MRES will spin-wait before taking lock
        Dim mres1 As New ManualResetEventSlim(False, 1000)
        Dim mres2 As New ManualResetEventSlim(False, 1000)

        Dim bgTask As Task = Task.Factory.StartNew(
            Sub()
                ' Just wait a little
                Thread.Sleep(100)

                ' Now signal both MRESes
                Console.WriteLine("Task signalling both MRESes")
                mres1.[Set]()
                mres2.[Set]()
            End Sub)

        ' A common use of MRES.WaitHandle is to use MRES as a participant in 
        ' WaitHandle.WaitAll/WaitAny. Note that accessing MRES.WaitHandle will
        ' result in the unconditional inflation of the underlying ManualResetEvent.
        WaitHandle.WaitAll(New WaitHandle() {mres1.WaitHandle, mres2.WaitHandle})
        Console.WriteLine("WaitHandle.WaitAll(mres1.WaitHandle, mres2.WaitHandle) completed.")

        ' Wait for bgTask to complete and clean up
        bgTask.Wait()
        mres1.Dispose()
        mres2.Dispose()
    End Sub
End Module

Açıklamalar

Bu sınıfı, bekleme sürelerinin çok kısa olması beklenenden ve olayın bir işlem sınırını aşmadığından daha iyi performans ManualResetEvent için kullanabilirsiniz. ManualResetEventSlim olayın sinyale dönüşmesini beklerken kısa bir süre meşgul dönen kullanır. Bekleme süreleri kısa olduğunda, bekleme tutamaçlarını kullanarak döndürmek beklemekten çok daha ucuz olabilir. Ancak, olay belirli bir süre içinde sinyal almazsa, ManualResetEventSlim normal bir olay tanıtıcısı beklemeye başvurur.

Not

.NET Core ve .NET 5+'ta varsayılan döndürme bekleme süresi kısadır: platforma ve işlemciye bağlı olarak 10 saniyelik mikrosaniye sırasına göre. Bekleme sürelerinin bundan çok daha uzun olmasını bekliyorsanız, yerine bu sınıfı ManualResetEvent kullanmaya devam edebilirsiniz (belki de daha az bekleme ile yapılandırılmış veya hiç bekleme ile yapılandırılmış olabilir). Ancak performans avantajı büyük olasılıkla yalnızca marjinal olacaktır.

Oluşturucular

ManualResetEventSlim()	sınıfın ManualResetEventSlim yeni bir örneğini ilk durumu imzalanmamış olarak başlatır.
ManualResetEventSlim(Boolean)	sınıfının yeni bir örneğini ManualResetEventSlim , ilk durumun sinyalli olarak ayarlanıp ayarlanmayacağını belirten bir Boole değeriyle başlatır.
ManualResetEventSlim(Boolean, Int32)	sınıfının yeni bir örneğini ManualResetEventSlim , ilk durumun sinyalli ve belirtilen döndürme sayısına ayarlanıp ayarlanmayacağını belirten bir Boole değeriyle başlatır.

Özellikler

IsSet	Olayın ayarlanıp ayarlanmadığını alır.
SpinCount	Çekirdek tabanlı bekleme işlemine geri dönmeden önce gerçekleşecek döndürme beklemelerinin sayısını alır.
WaitHandle	Bu ManualResetEventSlimiçin temel alınan WaitHandle nesneyi alır.

Yöntemler

Dispose()	ManualResetEventSlim sınıfının geçerli örneği tarafından kullanılan tüm kaynakları serbest bırakır.
Dispose(Boolean)	tarafından ManualResetEventSlimkullanılan yönetilmeyen kaynakları serbest bırakır ve isteğe bağlı olarak yönetilen kaynakları serbest bırakır.
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)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
Reset()	Olayın durumunu işaretsiz olarak ayarlar ve bu da iş parçacıklarının engellenmesine neden olur.
Set()	Olayın durumunu işaretlendi olarak ayarlar ve bu da olayın devam etmesini bekleyen bir veya daha fazla iş parçacığına izin verir.
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)
Wait()	Geçerli iş parçacığı, geçerli ManualResetEventSlim ayarlanana kadar engeller.
Wait(CancellationToken)	geçerli bir gözlemlerken bir sinyal alana kadar geçerli ManualResetEventSlim iş parçacığını CancellationTokenengeller.
Wait(Int32)	Zaman aralığını ölçmek için 32 bit imzalı bir tamsayı kullanarak geçerli iş parçacığını geçerli ManualResetEventSlim ayarlanana kadar engeller.
Wait(Int32, CancellationToken)	Bir gözlemlerken CancellationTokenzaman aralığını ölçmek için 32 bit imzalı bir tamsayı kullanarak geçerli iş parçacığını geçerli ManualResetEventSlim ayarlanana kadar engeller.
Wait(TimeSpan)	Zaman aralığını ölçmek için bir TimeSpan kullanarak geçerli iş parçacığını geçerli ManualResetEventSlim ayarlanana kadar engeller.
Wait(TimeSpan, CancellationToken)	geçerli ManualResetEventSlim ayarlanana kadar geçerli iş parçacığını engeller; bir gözlemlerken zaman aralığını ölçmek için bir TimeSpan CancellationTokenkullanılır.

Şunlara uygulanır

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

Tüm genel ve korumalı üyeleri ManualResetEventSlim iş parçacığı açısından güvenlidir ve yalnızca üzerindeki diğer tüm işlemler ManualResetEventSlim tamamlandığında kullanılması gereken Dispose ve yalnızca olaya erişen başka iş parçacığı olmadığında kullanılması gereken Reset dışında birden çok iş parçacığından eşzamanlı olarak kullanılabilir.

Ayrıca bkz.

Eşitleme temellerine genel bakış