ManualResetEventSlim Classe

Définition

Espace de noms:: System.Threading

Assemblys:: mscorlib.dll, System.Threading.dll

Assembly:: mscorlib.dll

Assembly:: System.Threading.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Représente un événement de synchronisation de threads qui, lorsqu’il est signalé, doit être réinitialisé manuellement. Cette classe est une alternative légère à 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: Object
ManualResetEventSlim

Attributs: ComVisibleAttribute

Implémente: IDisposable

Exemples

L’exemple suivant montre comment utiliser un 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 de meilleures performances que ManualResetEvent lorsque les temps d’attente sont censés être très courts, et lorsque l’événement ne dépasse pas une limite de processus. ManualResetEventSlim utilise l’épinglage occupé pendant une courte période pendant qu’il attend que l’événement devienne signalé. Lorsque les temps d’attente sont courts, l’épinglage peut être beaucoup moins coûteux que d’attendre en utilisant des poignées d’attente. Toutefois, si l’événement n’est pas signalé dans un certain temps, ManualResetEventSlim il se limite à une attente de handle d’événement standard.

Note

Dans .NET Core et .NET 5+, la durée d’attente par défaut est courte : sur l’ordre de 10 microsecondes, selon la plateforme et le processeur. Si vous attendez que les temps d’attente soient beaucoup plus longs que cela, vous pouvez toujours utiliser cette classe au lieu de ManualResetEvent (peut-être configuré avec moins ou pas d’attente). Toutefois, l’avantage de performance ne serait probablement que marginal.

Constructeurs

Nom	Description
ManualResetEventSlim()	Initialise une nouvelle instance de la ManualResetEventSlim classe avec un état initial de nonsignaled.
ManualResetEventSlim(Boolean, Int32)	Initialise une nouvelle instance de la ManualResetEventSlim classe avec une valeur booléenne indiquant s’il faut définir l’état initial sur signalé et un nombre de spins spécifié.
ManualResetEventSlim(Boolean)	Initialise une nouvelle instance de la ManualResetEventSlim classe avec une valeur booléenne indiquant s’il faut définir l’état initial à signaler.

Propriétés

Nom	Description
IsSet	Obtient si l’événement est défini.
SpinCount	Obtient le nombre d’attentes de rotation qui se produisent avant de revenir à une opération d’attente basée sur le noyau.
WaitHandle	Obtient l’objet sous-jacent WaitHandle pour ce ManualResetEventSlim.

Méthodes

Nom	Description
Dispose()	Libère toutes les ressources utilisées par l’instance actuelle de la ManualResetEventSlim classe.
Dispose(Boolean)	Libère les ressources non managées utilisées par le ManualResetEventSlim, et libère éventuellement les ressources managées.
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
Reset()	Définit l’état de l’événement sur non signé, ce qui entraîne le blocage des threads.
Set()	Définit l’état de l’événement à signaler, ce qui permet à un ou plusieurs threads en attente sur l’événement de continuer.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
Wait()	Bloque le thread actuel jusqu’à ce que le courant ManualResetEventSlim soit défini.
Wait(CancellationToken)	Bloque le thread actuel jusqu’à ce que le courant ManualResetEventSlim reçoive un signal, tout en observant un CancellationToken.
Wait(Int32, CancellationToken)	Bloque le thread actuel jusqu’à ce que le courant ManualResetEventSlim soit défini, à l’aide d’un entier signé 32 bits pour mesurer l’intervalle de temps, lors de l’observation d’un CancellationToken.
Wait(Int32)	Bloque le thread actuel jusqu’à ce que le courant ManualResetEventSlim soit défini, à l’aide d’un entier signé 32 bits pour mesurer l’intervalle de temps.
Wait(TimeSpan, CancellationToken)	Bloque le thread actuel jusqu’à ce que le courant ManualResetEventSlim soit défini, en utilisant un TimeSpan pour mesurer l’intervalle de temps, lors de l’observation d’un CancellationToken.
Wait(TimeSpan)	Bloque le thread actuel jusqu’à ce que le courant ManualResetEventSlim soit défini, à l’aide d’une TimeSpan mesure de l’intervalle de temps.

S’applique à

Cohérence de thread

Tous les membres publics et protégés d’entre ManualResetEventSlim eux sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads, à l’exception de Dispose, qui ne doit être utilisé que lorsque toutes les autres opérations sur le ManualResetEventSlim site sont terminées, et réinitialiser, qui ne doivent être utilisées que lorsqu’aucun autre thread n’accède à l’événement.

Voir aussi

Vue d’ensemble des primitives de synchronisation

Commentaires

Cette page a-t-elle été utile ?