ManualResetEventSlim Classe

Définition

Représente un événement de synchronisation de thread qui, quand il est signalé, doit être réinitialisé manuellement.Represents a thread synchronization event that, when signaled, must be reset manually. Cette classe est une alternative légère à ManualResetEvent.This class is a lightweight alternative to ManualResetEvent.

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
Héritage
ManualResetEventSlim
Attributs
Implémente

Exemples

L’exemple suivant montre comment utiliser un ManualResetEventSlim .The following example shows how to use a 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

Remarques

Vous pouvez utiliser cette classe pour obtenir de meilleures performances que ManualResetEvent lorsque les temps d’attente sont supposés être très courts et lorsque l’événement ne franchit pas une limite de processus.You can use this class for better performance than ManualResetEvent when wait times are expected to be very short, and when the event does not cross a process boundary. ManualResetEventSlim utilise la rotation intensive pendant une courte période, tout en attendant la signalisation de l’événement.ManualResetEventSlim uses busy spinning for a short time while it waits for the event to become signaled. Lorsque les temps d’attente sont courts, la rotation peut s’avérer beaucoup moins coûteuse que les descripteurs d’attente.When wait times are short, spinning can be much less expensive than waiting by using wait handles. Toutefois, si l’événement n’est pas signalé pendant une période définie, ManualResetEventSlim recourt à une attente de descripteur d’événement classique.However, if the event does not become signaled within a certain period of time, ManualResetEventSlim resorts to a regular event handle wait.

Constructeurs

ManualResetEventSlim()

Initialise une nouvelle instance de la classe ManualResetEventSlim avec "non signalé" comme état initial.Initializes a new instance of the ManualResetEventSlim class with an initial state of nonsignaled.

ManualResetEventSlim(Boolean)

Initialise une nouvelle instance de la classe ManualResetEventSlim avec une valeur booléenne indiquant si l'état initial doit être défini comme signalé.Initializes a new instance of the ManualResetEventSlim class with a Boolean value indicating whether to set the initial state to signaled.

ManualResetEventSlim(Boolean, Int32)

Initialise une nouvelle instance de la classe ManualResetEventSlim avec une valeur booléenne indiquant si l’état initial doit être défini comme étant signalé et un nombre de spins spécifié.Initializes a new instance of the ManualResetEventSlim class with a Boolean value indicating whether to set the initial state to signaled and a specified spin count.

Propriétés

IsSet

Obtient une valeur qui indique si l'événement est défini.Gets whether the event is set.

SpinCount

Obtient le nombre d’attentes de spins qui se produiront avant de revenir à une opération d’attente basée sur le noyau.Gets the number of spin waits that will occur before falling back to a kernel-based wait operation.

WaitHandle

Obtient l'objet WaitHandle sous-jacent pour ce ManualResetEventSlim.Gets the underlying WaitHandle object for this ManualResetEventSlim.

Méthodes

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe ManualResetEventSlim.Releases all resources used by the current instance of the ManualResetEventSlim class.

Dispose(Boolean)

Libère les ressources non managées utilisées par le ManualResetEventSlim, et libère éventuellement les ressources managées.Releases the unmanaged resources used by the ManualResetEventSlim, and optionally releases the managed resources.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
Reset()

Définit l'état de l'événement à "non signalé", ce qui entraîne le blocage des threads.Sets the state of the event to nonsignaled, which causes threads to block.

Set()

Définit l'état de l'événement à "signalé", ce qui permet à un ou plusieurs threads en attente sur l'événement de continuer à s'exécuter.Sets the state of the event to signaled, which allows one or more threads waiting on the event to proceed.

ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)
Wait()

Bloque le thread actuel jusqu'à ce que le ManualResetEventSlim actuel soit défini.Blocks the current thread until the current ManualResetEventSlim is set.

Wait(CancellationToken)

Bloque le thread actuel jusqu'à ce que le ManualResetEventSlim actuel reçoive un signal, tout en observant un CancellationToken.Blocks the current thread until the current ManualResetEventSlim receives a signal, while observing a CancellationToken.

Wait(Int32)

Bloque le thread actuel jusqu'à ce que le ManualResetEventSlim actuel soit défini, à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps.Blocks the current thread until the current ManualResetEventSlim is set, using a 32-bit signed integer to measure the time interval.

Wait(Int32, CancellationToken)

Bloque le thread actuel jusqu'à ce que le ManualResetEventSlim actuel soit défini, à l'aide d'un entier signé 32 bits pour mesurer l'intervalle de temps, tout en observant un CancellationToken.Blocks the current thread until the current ManualResetEventSlim is set, using a 32-bit signed integer to measure the time interval, while observing a CancellationToken.

Wait(TimeSpan)

Bloque le thread actuel jusqu'à ce que le ManualResetEventSlim actuel soit défini, à l'aide d'un TimeSpan pour mesurer l'intervalle de temps.Blocks the current thread until the current ManualResetEventSlim is set, using a TimeSpan to measure the time interval.

Wait(TimeSpan, CancellationToken)

Bloque le thread actuel jusqu'à ce que le ManualResetEventSlim actuel soit défini, à l'aide d'un TimeSpan pour mesurer l'intervalle de temps, tout en observant un CancellationToken.Blocks the current thread until the current ManualResetEventSlim is set, using a TimeSpan to measure the time interval, while observing a CancellationToken.

S’applique à

Cohérence de thread

Tous les membres publics et protégés de ManualResetEventSlim sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads, à l’exception de dispose, qui doit uniquement être utilisé lorsque toutes les autres opérations sur le ManualResetEventSlim sont terminées, et Reset, qui doit être utilisé uniquement quand aucun autre thread n’accède à l’événement.All public and protected members of ManualResetEventSlim are thread-safe and may be used concurrently from multiple threads, with the exception of Dispose, which must only be used when all other operations on the ManualResetEventSlim have completed, and Reset, which should only be used when no other threads are accessing the event.

Voir aussi