WaitHandle.WaitOne Metoda

Definice

Obor názvů:

System.Threading

Sestavení:

netstandard.dll, System.Runtime.dll

Blokuje aktuální vlákno, dokud proud WaitHandle neobdrží signál.

Přetížení

Name	Description
WaitOne()	Blokuje aktuální vlákno, dokud proud WaitHandle neobdrží signál.
WaitOne(Int32)	Blokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určuje časový interval v milisekundách.
WaitOne(TimeSpan)	Blokuje aktuální vlákno, dokud aktuální instance neobdrží signál pomocí TimeSpan k určení časového intervalu.
WaitOne(Int32, Boolean)	Zablokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určí časový interval a určí, jestli se má před čekáním ukončit synchronizační doména.
WaitOne(TimeSpan, Boolean)	Zablokuje aktuální vlákno, dokud aktuální instance neobdrží signál, pomocí parametru TimeSpan a určí, zda se má před čekáním ukončit synchronizační doména.

WaitOne()

Zdroj:

WaitHandle.cs

Blokuje aktuální vlákno, dokud proud WaitHandle neobdrží signál.

public:
 virtual bool WaitOne();

public virtual bool WaitOne();

abstract member WaitOne : unit -> bool
override this.WaitOne : unit -> bool

Public Overridable Function WaitOne () As Boolean

Návraty

Boolean

true pokud aktuální instance obdrží signál. Pokud aktuální instance není nikdy signalována, WaitOne() nikdy se nevrátí.

Výjimky

ObjectDisposedException

Aktuální instance již byla uvolněna.

AbandonedMutexException

Čekání bylo dokončeno, protože vlákno se ukončilo bez uvolnění mutexu.

InvalidOperationException

Aktuální instance je transparentní proxy server pro jinou WaitHandle doménu aplikace.

Příklady

Následující příklad kódu ukazuje, jak pomocí obslužného rutiny čekání udržet proces před ukončením, zatímco čeká na dokončení provádění vlákna na pozadí.

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        autoEvent.WaitOne();
        Console.WriteLine("Work method signaled.\nMain ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        autoEvent.WaitOne()
        Console.WriteLine("Work method signaled.")
        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Poznámky

AbandonedMutexException je novinka v rozhraní .NET Framework verze 2.0. V předchozích verzích WaitOne vrátí true metoda při opuštění mutexu. Opuštěný mutex často značí závažnou chybu kódování. V případě mutexu celého systému může značit, že aplikace byla náhle ukončena (například pomocí Správce úloh systému Windows). Výjimka obsahuje informace užitečné pro ladění.

Volající této metody blokuje neomezeně dlouhou dobu, dokud aktuální instance neobdrží signál. Tuto metodu použijte k blokování, dokud WaitHandle neobdrží signál z jiného vlákna, například je generován při dokončení asynchronní operace. Další informace najdete v rozhraní IAsyncResult.

Volání tohoto přetížení metody je ekvivalentní volání WaitOne(Int32, Boolean) přetížení metody a určení -1 nebo Timeout.Infinite pro první parametr a false druhý parametr.

Přepsat tuto metodu přizpůsobit chování odvozených tříd.

WaitOne(Int32)

Zdroj:

WaitHandle.cs

Blokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určuje časový interval v milisekundách.

public:
 virtual bool WaitOne(int millisecondsTimeout);

public virtual bool WaitOne(int millisecondsTimeout);

abstract member WaitOne : int -> bool
override this.WaitOne : int -> bool

Public Overridable Function WaitOne (millisecondsTimeout As Integer) As Boolean

Parametry

millisecondsTimeout

Int32

Počet milisekund, které se mají počkat, nebo Infinite (-1) čekat na neomezenou dobu.

Návraty

Boolean

truepokud aktuální instance obdrží signál; v opačném případě . false

Výjimky

ObjectDisposedException

Aktuální instance již byla uvolněna.

ArgumentOutOfRangeException

millisecondsTimeout je záporné číslo jiné než -1, což představuje nekonečný časový limit.

AbandonedMutexException

Čekání bylo dokončeno, protože vlákno se ukončilo bez uvolnění mutexu.

InvalidOperationException

Aktuální instance je transparentní proxy server pro jinou WaitHandle doménu aplikace.

Příklady

Následující příklad kódu ukazuje, jak pomocí obslužného rutiny čekání udržet proces před ukončením, zatímco čeká na dokončení provádění vlákna na pozadí.

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(1000))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        If autoEvent.WaitOne(1000) Then
            Console.WriteLine("Work method signaled.")
        Else
            Console.WriteLine("Timed out waiting for work " & _
                "method to signal.")
        End If

        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Poznámky

Pokud millisecondsTimeout je nula, metoda neblokuje. Testuje stav popisovače čekání a vrátí okamžitě.

Volající této metody blokuje, dokud aktuální instance neobdrží signál nebo dojde k vypršení časového limitu. Tuto metodu použijte k blokování, dokud WaitHandle neobdrží signál z jiného vlákna, například je generován při dokončení asynchronní operace. Další informace najdete v rozhraní IAsyncResult.

Přepsat tuto metodu přizpůsobit chování odvozených tříd.

Volání této přetížení metody je stejné jako volání WaitOne(Int32, Boolean) přetížení a určení false pro exitContext.

WaitOne(TimeSpan)

Zdroj:

WaitHandle.cs

Blokuje aktuální vlákno, dokud aktuální instance neobdrží signál pomocí TimeSpan k určení časového intervalu.

public:
 virtual bool WaitOne(TimeSpan timeout);

public virtual bool WaitOne(TimeSpan timeout);

abstract member WaitOne : TimeSpan -> bool
override this.WaitOne : TimeSpan -> bool

Public Overridable Function WaitOne (timeout As TimeSpan) As Boolean

Parametry

timeout

TimeSpan

Jedná TimeSpan se o počet milisekund, které se mají čekat, nebo TimeSpan počet milisekund, které představují -1 milisekundy, které se mají čekat neomezeně dlouho.

Návraty

Boolean

truepokud aktuální instance obdrží signál; v opačném případě . false

Výjimky

ObjectDisposedException

Aktuální instance již byla uvolněna.

ArgumentOutOfRangeException

timeout je záporné číslo jiné než -1 milisekund, což představuje nekonečný časový limit.

nebo

timeout je větší než Int32.MaxValue.

AbandonedMutexException

Čekání bylo dokončeno, protože vlákno se ukončilo bez uvolnění mutexu.

InvalidOperationException

Aktuální instance je transparentní proxy server pro jinou WaitHandle doménu aplikace.

Poznámky

Pokud timeout je nula, metoda neblokuje. Testuje stav popisovače čekání a vrátí okamžitě.

Volající této metody blokuje, dokud aktuální instance neobdrží signál nebo dojde k vypršení časového limitu. Tuto metodu použijte k blokování, dokud WaitHandle neobdrží signál z jiného vlákna, například je generován při dokončení asynchronní operace. Další informace najdete v rozhraní IAsyncResult.

Přepsat tuto metodu přizpůsobit chování odvozených tříd.

Maximální hodnota pro timeout hodnotu je Int32.MaxValue.

Volání této přetížení metody je stejné jako volání WaitOne(TimeSpan, Boolean) přetížení a určení false pro exitContext.

WaitOne(Int32, Boolean)

Zdroj:

WaitHandle.cs

Zablokuje aktuální vlákno, dokud aktuální WaitHandle neobdrží signál, pomocí 32bitového znaménka integer určí časový interval a určí, jestli se má před čekáním ukončit synchronizační doména.

public:
 virtual bool WaitOne(int millisecondsTimeout, bool exitContext);

public virtual bool WaitOne(int millisecondsTimeout, bool exitContext);

abstract member WaitOne : int * bool -> bool
override this.WaitOne : int * bool -> bool

Public Overridable Function WaitOne (millisecondsTimeout As Integer, exitContext As Boolean) As Boolean

Parametry

millisecondsTimeout

Int32

Počet milisekund, které se mají počkat, nebo Infinite (-1) čekat na neomezenou dobu.

exitContext

Boolean

trueukončit synchronizační doménu pro kontext před čekáním (pokud je v synchronizovaném kontextu) a potom ji znovu požádat; v opačném případě . false

Návraty

Boolean

truepokud aktuální instance obdrží signál; v opačném případě . false

Výjimky

ObjectDisposedException

Aktuální instance již byla uvolněna.

ArgumentOutOfRangeException

millisecondsTimeout je záporné číslo jiné než -1, což představuje nekonečný časový limit.

AbandonedMutexException

Čekání bylo dokončeno, protože vlákno se ukončilo bez uvolnění mutexu.

InvalidOperationException

Aktuální instance je transparentní proxy server pro jinou WaitHandle doménu aplikace.

Příklady

Následující příklad ukazuje, jak WaitOne(Int32, Boolean) se přetížení metody chová, když je volána v rámci synchronizační domény. Nejprve vlákno čeká s nastaveným exitContextfalse nastavením a bloky, dokud nevyprší časový limit čekání. Druhé vlákno se spustí po ukončení prvního vlákna a počká s nastaveným exitContext na true. Volání signalizovat popisovač čekání pro toto druhé vlákno není blokováno a vlákno se dokončí před vypršením časového limitu čekání.

using System;
using System.Threading;
using System.Runtime.Remoting.Contexts;

[Synchronization(true)]
public class SyncingClass : ContextBoundObject
{
    private EventWaitHandle waitHandle;

    public SyncingClass()
    {
         waitHandle =
            new EventWaitHandle(false, EventResetMode.ManualReset);
    }

    public void Signal()
    {
        Console.WriteLine("Thread[{0:d4}]: Signalling...", Thread.CurrentThread.GetHashCode());
        waitHandle.Set();
    }

    public void DoWait(bool leaveContext)
    {
        bool signalled;

        waitHandle.Reset();
        Console.WriteLine("Thread[{0:d4}]: Waiting...", Thread.CurrentThread.GetHashCode());
        signalled = waitHandle.WaitOne(3000, leaveContext);
        if (signalled)
        {
            Console.WriteLine("Thread[{0:d4}]: Wait released!!!", Thread.CurrentThread.GetHashCode());
        }
        else
        {
            Console.WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread.CurrentThread.GetHashCode());
        }
    }
}

public class TestSyncDomainWait
{
    public static void Main()
    {
        SyncingClass syncClass = new SyncingClass();

        Thread runWaiter;

        Console.WriteLine("\nWait and signal INSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitKeepContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal will block until the timeout in DoWait expires.
        syncClass.Signal();
        runWaiter.Join();

        Console.WriteLine("\nWait and signal OUTSIDE synchronization domain:\n");
        runWaiter = new Thread(RunWaitLeaveContext);
        runWaiter.Start(syncClass);
        Thread.Sleep(1000);
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode());
        // This call to Signal is unblocked and will set the wait handle to
        // release the waiting thread.
        syncClass.Signal();
        runWaiter.Join();
    }

    public static void RunWaitKeepContext(object parm)
    {
        ((SyncingClass)parm).DoWait(false);
    }

    public static void RunWaitLeaveContext(object parm)
    {
        ((SyncingClass)parm).DoWait(true);
    }
}

// The output for the example program will be similar to the following:
//
// Wait and signal INSIDE synchronization domain:
//
// Thread[0004]: Waiting...
// Thread[0001]: Signal...
// Thread[0004]: Wait timeout!!!
// Thread[0001]: Signalling...
//
// Wait and signal OUTSIDE synchronization domain:
//
// Thread[0006]: Waiting...
// Thread[0001]: Signal...
// Thread[0001]: Signalling...
// Thread[0006]: Wait released!!!

Imports System.Threading
Imports System.Runtime.Remoting.Contexts

<Synchronization(true)>
Public Class SyncingClass
    Inherits ContextBoundObject
    
    Private waitHandle As EventWaitHandle

    Public Sub New()
         waitHandle = New EventWaitHandle(false, EventResetMode.ManualReset)
    End Sub

    Public Sub Signal()
        Console.WriteLine("Thread[{0:d4}]: Signalling...", Thread.CurrentThread.GetHashCode())
        waitHandle.Set()
    End Sub

    Public Sub DoWait(leaveContext As Boolean)
        Dim signalled As Boolean

        waitHandle.Reset()
        Console.WriteLine("Thread[{0:d4}]: Waiting...", Thread.CurrentThread.GetHashCode())
        signalled = waitHandle.WaitOne(3000, leaveContext)
        If signalled Then
            Console.WriteLine("Thread[{0:d4}]: Wait released!!!", Thread.CurrentThread.GetHashCode())
        Else
            Console.WriteLine("Thread[{0:d4}]: Wait timeout!!!", Thread.CurrentThread.GetHashCode())
        End If
    End Sub
End Class

Public Class TestSyncDomainWait
    Public Shared Sub Main()
        Dim syncClass As New SyncingClass()

        Dim runWaiter As Thread

        Console.WriteLine(Environment.NewLine + "Wait and signal INSIDE synchronization domain:" + Environment.NewLine)
        runWaiter = New Thread(AddressOf RunWaitKeepContext)
        runWaiter.Start(syncClass)
        Thread.Sleep(1000)
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode())
        ' This call to Signal will block until the timeout in DoWait expires.
        syncClass.Signal()
        runWaiter.Join()

        Console.WriteLine(Environment.NewLine + "Wait and signal OUTSIDE synchronization domain:" + Environment.NewLine)
        runWaiter = New Thread(AddressOf RunWaitLeaveContext)
        runWaiter.Start(syncClass)
        Thread.Sleep(1000)
        Console.WriteLine("Thread[{0:d4}]: Signal...", Thread.CurrentThread.GetHashCode())
        ' This call to Signal is unblocked and will set the wait handle to
        ' release the waiting thread.
        syncClass.Signal()
        runWaiter.Join()
    End Sub

    Public Shared Sub RunWaitKeepContext(parm As Object)
        Dim syncClass As SyncingClass = CType(parm, SyncingClass)
        syncClass.DoWait(False)
    End Sub

    Public Shared Sub RunWaitLeaveContext(parm As Object)
        Dim syncClass As SyncingClass = CType(parm, SyncingClass)
        syncClass.DoWait(True)
    End Sub
End Class

' The output for the example program will be similar to the following:
'
' Wait and signal INSIDE synchronization domain:
'
' Thread[0004]: Waiting...
' Thread[0001]: Signal...
' Thread[0004]: Wait timeout!!!
' Thread[0001]: Signalling...
'
' Wait and signal OUTSIDE synchronization domain:
'
' Thread[0006]: Waiting...
' Thread[0001]: Signal...
' Thread[0001]: Signalling...
' Thread[0006]: Wait released!!!

Poznámky

Pokud millisecondsTimeout je nula, metoda neblokuje. Testuje stav popisovače čekání a vrátí okamžitě.

Pokud je mutex opuštěný, AbandonedMutexException je vyvolán. Opuštěný mutex často značí závažnou chybu kódování. V případě mutexu celého systému může značit, že aplikace byla náhle ukončena (například pomocí Správce úloh systému Windows). Výjimka obsahuje informace užitečné pro ladění.

Volající této metody blokuje, dokud aktuální instance neobdrží signál nebo dojde k vypršení časového limitu. Tuto metodu použijte k blokování, dokud WaitHandle neobdrží signál z jiného vlákna, například je generován při dokončení asynchronní operace. Další informace najdete v rozhraní IAsyncResult.

Přepsat tuto metodu přizpůsobit chování odvozených tříd.

Ukončení kontextu

Parametr exitContext nemá žádný vliv, pokud tato metoda není volána z nedefault spravovaného kontextu. Spravovaný kontext může být nedefaultní, pokud je vlákno uvnitř volání instance třídy odvozené z ContextBoundObject. I když aktuálně spouštíte metodu ve třídě, která není odvozená od ContextBoundObject, například String, můžete být v nedefaultním kontextu, pokud ContextBoundObject je ve vašem zásobníku v aktuální doméně aplikace.

Když se váš kód spouští v nedefaultním kontextu, určuje true , že vlákno exitContext ukončí nedefaultní spravovaný kontext (to znamená přechod na výchozí kontext) před spuštěním této metody. Vlákno se vrátí do původního nedefault kontextu po dokončení volání této metody.

Ukončení kontextu může být užitečné, pokud má třída vázané na SynchronizationAttribute kontext atribut. V takovém případě jsou všechna volání členů třídy automaticky synchronizována a synchronizační doména je celý text kódu pro třídu. Pokud kód v zásobníku volání člen volá tuto metodu a určuje true pro exitContext, vlákno ukončí synchronizační doménu, což umožňuje vlákno blokované při volání libovolného člena objektu pokračovat. Když tato metoda vrátí, vlákno, které provedlo volání, musí počkat na opětovné zadání synchronizační domény.

WaitOne(TimeSpan, Boolean)

Zdroj:

WaitHandle.cs

Zablokuje aktuální vlákno, dokud aktuální instance neobdrží signál, pomocí parametru TimeSpan a určí, zda se má před čekáním ukončit synchronizační doména.

public:
 virtual bool WaitOne(TimeSpan timeout, bool exitContext);

public virtual bool WaitOne(TimeSpan timeout, bool exitContext);

abstract member WaitOne : TimeSpan * bool -> bool
override this.WaitOne : TimeSpan * bool -> bool

Public Overridable Function WaitOne (timeout As TimeSpan, exitContext As Boolean) As Boolean

Parametry

timeout

TimeSpan

Jedná TimeSpan se o počet milisekund, které se mají čekat, nebo TimeSpan počet milisekund, které představují -1 milisekundy, které se mají čekat neomezeně dlouho.

exitContext

Boolean

trueukončit synchronizační doménu pro kontext před čekáním (pokud je v synchronizovaném kontextu) a potom ji znovu požádat; v opačném případě . false

Návraty

Boolean

truepokud aktuální instance obdrží signál; v opačném případě . false

Výjimky

ObjectDisposedException

Aktuální instance již byla uvolněna.

ArgumentOutOfRangeException

timeout je záporné číslo jiné než -1 milisekund, což představuje nekonečný časový limit.

nebo

timeout je větší než Int32.MaxValue.

AbandonedMutexException

Čekání bylo dokončeno, protože vlákno se ukončilo bez uvolnění mutexu.

InvalidOperationException

Aktuální instance je transparentní proxy server pro jinou WaitHandle doménu aplikace.

Příklady

Následující příklad kódu ukazuje, jak pomocí obslužného rutiny čekání udržet proces před ukončením, zatímco čeká na dokončení provádění vlákna na pozadí.

using System;
using System.Threading;

class WaitOne
{
    static AutoResetEvent autoEvent = new AutoResetEvent(false);

    static void Main()
    {
        Console.WriteLine("Main starting.");

        ThreadPool.QueueUserWorkItem(
            new WaitCallback(WorkMethod), autoEvent);

        // Wait for work method to signal.
        if(autoEvent.WaitOne(new TimeSpan(0, 0, 1), false))
        {
            Console.WriteLine("Work method signaled.");
        }
        else
        {
            Console.WriteLine("Timed out waiting for work " +
                "method to signal.");
        }
        Console.WriteLine("Main ending.");
    }

    static void WorkMethod(object stateInfo) 
    {
        Console.WriteLine("Work starting.");

        // Simulate time spent working.
        Thread.Sleep(new Random().Next(100, 2000));

        // Signal that work is finished.
        Console.WriteLine("Work ending.");
        ((AutoResetEvent)stateInfo).Set();
    }
}

Imports System.Threading

Public Class WaitOne

    Shared autoEvent As New AutoResetEvent(False)

    <MTAThread> _
    Shared Sub Main()
        Console.WriteLine("Main starting.")

        ThreadPool.QueueUserWorkItem(AddressOf WorkMethod, autoEvent)

        ' Wait for work method to signal.
        If autoEvent.WaitOne(New TimeSpan(0, 0, 1), False) Then
            Console.WriteLine("Work method signaled.")
        Else
            Console.WriteLine("Timed out waiting for work " & _
                "method to signal.")
        End If

        Console.WriteLine("Main ending.")
    End Sub

    Shared Sub WorkMethod(stateInfo As Object) 
        Console.WriteLine("Work starting.")

        ' Simulate time spent working.
        Thread.Sleep(New Random().Next(100, 2000))

        ' Signal that work is finished.
        Console.WriteLine("Work ending.")
        CType(stateInfo, AutoResetEvent).Set()
    End Sub

End Class

Poznámky

Pokud timeout je nula, metoda neblokuje. Testuje stav popisovače čekání a vrátí okamžitě.

Pokud je mutex opuštěný, AbandonedMutexException je vyvolán. Opuštěný mutex často značí závažnou chybu kódování. V případě mutexu celého systému může značit, že aplikace byla náhle ukončena (například pomocí Správce úloh systému Windows). Výjimka obsahuje informace užitečné pro ladění.

Volající této metody blokuje, dokud aktuální instance neobdrží signál nebo dojde k vypršení časového limitu. Tuto metodu použijte k blokování, dokud WaitHandle neobdrží signál z jiného vlákna, například je generován při dokončení asynchronní operace. Další informace najdete v rozhraní IAsyncResult.

Přepsat tuto metodu přizpůsobit chování odvozených tříd.

Maximální hodnota pro timeout hodnotu je Int32.MaxValue.

Ukončení kontextu

Parametr exitContext nemá žádný vliv, pokud tato metoda není volána z nedefault spravovaného kontextu. Spravovaný kontext může být nedefaultní, pokud je vlákno uvnitř volání instance třídy odvozené z ContextBoundObject. I když aktuálně spouštíte metodu ve třídě, která není odvozená od ContextBoundObject, například String, můžete být v nedefaultním kontextu, pokud ContextBoundObject je ve vašem zásobníku v aktuální doméně aplikace.

Když se váš kód spouští v nedefaultním kontextu, určuje true , že vlákno exitContext ukončí nedefaultní spravovaný kontext (to znamená přechod na výchozí kontext) před spuštěním této metody. Vlákno se vrátí do původního nedefault kontextu po dokončení volání této metody.

Ukončení kontextu může být užitečné, pokud má třída vázané na SynchronizationAttribute kontext atribut. V takovém případě jsou všechna volání členů třídy automaticky synchronizována a synchronizační doména je celý text kódu pro třídu. Pokud kód v zásobníku volání člen volá tuto metodu a určuje true pro exitContext, vlákno ukončí synchronizační doménu, což umožňuje vlákno blokované při volání libovolného člena objektu pokračovat. Když tato metoda vrátí, vlákno, které provedlo volání, musí počkat na opětovné zadání synchronizační domény.