ManualResetEventSlim Sınıf

Tanım

Ad Alanı:

System.Threading

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Threading.dll

Kaynak:

ManualResetEventSlim.cs

İş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

type ManualResetEventSlim = class
    interface IDisposable

Public Class ManualResetEventSlim
Implements IDisposable

Devralma

Object

ManualResetEventSlim

Uygulamalar

IDisposable

Örnekler

Aşağıdaki örnekte 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

Bekleme sürelerinin çok kısa olması beklenenden ve olayın bir işlem sınırını aşmadığından daha ManualResetEvent iyi performans için bu sınıfı kullanabilirsiniz. ManualResetEventSlim olayın sinyallemesini beklerken kısa bir süre için dönen meşgul 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.

Note

.NET Core ve 5+ .NET varsayılan döndürme bekleme süresi kısadır: platforma ve işlemciye bağlı olarak 10 saniyelik düzende. Bekleme sürelerinin bundan çok daha uzun olmasını bekliyorsanız, yerine bu sınıfı ManualResetEvent kullanmaya devam edebilirsiniz (belki de daha az 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

Name	Description
ManualResetEventSlim()	İlk durumu imzalanmamış olan sınıfın yeni bir örneğini ManualResetEventSlim 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ı olarak ayarlanıp ayarlanmayacağını belirten boole değeriyle başlatır.
ManualResetEventSlim(Boolean)	İlk durumun işaretlendi olarak ayarlanıp ayarlanmayacağını ManualResetEventSlim belirten boole değeriyle sınıfının yeni bir örneğini başlatır.

Özellikler

Name	Description
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 WaitHandleiçin temel alınan ManualResetEventSlim nesneyi alır.

Yöntemler

Name	Description
Dispose()	Sınıfın geçerli örneği ManualResetEventSlim 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()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
MemberwiseClone()	Geçerli Objectbasit 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şaretlenmek üzere 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 bir dize döndürür. (Devralındığı yer: Object)
Wait()	Geçerli iş parçacığını geçerli ManualResetEventSlim ayarlanana kadar engeller.
Wait(CancellationToken)	Geçerli iş parçacığını, bir gözlemlerken geçerli ManualResetEventSlim bir sinyal alana CancellationTokenkadar engeller.
Wait(Int32, CancellationToken)	Geçerli iş parçacığını geçerli ayarlanana ManualResetEventSlim kadar engeller; zaman aralığını ölçmek için 32 bit imzalı bir tamsayı kullanarak bir CancellationTokengözlemlerken.
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(TimeSpan, CancellationToken)	Geçerli iş parçacığını, bir gözlemlerken ManualResetEventSlimzaman aralığını ölçmek için kullanarak TimeSpan geçerli CancellationToken iş parçacığını engeller.
Wait(TimeSpan)	Zaman aralığını ölçmek için kullanarak ManualResetEventSlim geçerli iş parçacığını geçerli TimeSpan ayarlanıncaya kadar engeller.

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

'nin ManualResetEventSlim tüm genel ve korumalı üyeleri 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 temel bilgilerine genel bakış