Uwaga
Dostęp do tej strony wymaga autoryzacji. Może spróbować zalogować się lub zmienić katalogi.
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować zmienić katalogi.
Jeśli metoda jest zablokowana podczas oczekiwania na zasygnalizację zdarzenia, nie może sprawdzić wartości tokenu anulowania i odpowiedzieć w odpowiednim czasie. W pierwszym przykładzie pokazano, jak rozwiązać ten problem podczas pracy z zdarzeniami, takimi jak System.Threading.ManualResetEvent te, które nie obsługują natywnie ujednoliconej struktury anulowania. W drugim przykładzie przedstawiono bardziej usprawnione podejście korzystające z System.Threading.ManualResetEventSlimmetody , która obsługuje ujednolicone anulowanie.
Uwaga
Po włączeniu opcji "Tylko mój kod" program Visual Studio w niektórych przypadkach przerwie w wierszu, który zgłasza wyjątek i wyświetla komunikat o błędzie z komunikatem "wyjątek nie jest obsługiwany przez kod użytkownika". Ten błąd jest łagodny. Możesz nacisnąć klawisz F5, aby kontynuować działanie, i zobaczyć zachowanie obsługi wyjątków, które przedstawiono w poniższych przykładach. Aby zapobiec uszkodzeniu pierwszego błędu programu Visual Studio, usuń zaznaczenie pola wyboru "Tylko mój kod" w obszarze Narzędzia, Opcje, Debugowanie, Ogólne.
Przykład 1
W poniższym przykładzie użyto metody , ManualResetEvent aby zademonstrować, jak odblokować uchwyty oczekiwania, które nie obsługują ujednoliconego anulowania.
using System;
using System.Threading;
using System.Threading.Tasks;
class CancelOldStyleEvents
{
// Old-style MRE that doesn't support unified cancellation.
static ManualResetEvent mre = new ManualResetEvent(false);
static void Main()
{
var cts = new CancellationTokenSource();
// Pass the same token source to the delegate and to the task instance.
Task.Run(() => DoWork(cts.Token), cts.Token);
Console.WriteLine("Press s to start/restart, p to pause, or c to cancel.");
Console.WriteLine("Or any other key to exit.");
// Old-style UI thread.
bool goAgain = true;
while (goAgain)
{
char ch = Console.ReadKey(true).KeyChar;
switch (ch)
{
case 'c':
cts.Cancel();
break;
case 'p':
mre.Reset();
break;
case 's':
mre.Set();
break;
default:
goAgain = false;
break;
}
Thread.Sleep(100);
}
cts.Dispose();
}
static void DoWork(CancellationToken token)
{
while (true)
{
// Wait on the event if it is not signaled.
int eventThatSignaledIndex =
WaitHandle.WaitAny(new WaitHandle[] { mre, token.WaitHandle },
new TimeSpan(0, 0, 20));
// Were we canceled while waiting?
if (eventThatSignaledIndex == 1)
{
Console.WriteLine("The wait operation was canceled.");
throw new OperationCanceledException(token);
}
// Were we canceled while running?
else if (token.IsCancellationRequested)
{
Console.WriteLine("I was canceled while running.");
token.ThrowIfCancellationRequested();
}
// Did we time out?
else if (eventThatSignaledIndex == WaitHandle.WaitTimeout)
{
Console.WriteLine("I timed out.");
break;
}
else
{
Console.Write("Working... ");
// Simulating work.
Thread.SpinWait(5000000);
}
}
}
}
Imports System.Threading
Imports System.Threading.Tasks
Class CancelOldStyleEvents
' Old-style MRE that doesn't support unified cancellation.
Shared mre As New ManualResetEvent(False)
Shared Sub Main9()
Dim cts As New CancellationTokenSource()
' Pass the same token source to the delegate and to the task instance.
Task.Run(Sub() DoWork(cts.Token), cts.Token)
Console.WriteLine("Press c to cancel, p to pause, or s to start/restart.")
Console.WriteLine("Or any other key to exit.")
' Old-style UI thread.
Dim goAgain As Boolean = True
While goAgain
Dim ch As Char = Console.ReadKey(True).KeyChar
Select Case ch
Case "c"c
cts.Cancel()
Case "p"c
mre.Reset()
Case "s"c
mre.Set()
Case Else
goAgain = False
End Select
Thread.Sleep(100)
End While
cts.Dispose()
End Sub
Shared Sub DoWork(ByVal token As CancellationToken)
While True
' Wait on the event if it is not signaled.
Dim waitHandles() As WaitHandle = {mre, token.WaitHandle}
Dim eventThatSignaledIndex =
WaitHandle.WaitAny(waitHandles, _
New TimeSpan(0, 0, 20))
' Were we canceled while waiting?
' The first If statement is equivalent to
' token.ThrowIfCancellationRequested()
If eventThatSignaledIndex = 1 Then
Console.WriteLine("The wait operation was canceled.")
Throw New OperationCanceledException(token)
' Were we canceled while running?
ElseIf token.IsCancellationRequested = True Then
Console.WriteLine("Cancelling per user request.")
token.ThrowIfCancellationRequested()
' Did we time out?
ElseIf eventThatSignaledIndex = WaitHandle.WaitTimeout Then
Console.WriteLine("The wait operation timed out.")
Exit While
Else
' Simulating work.
Console.Write("Working... ")
Thread.SpinWait(5000000)
End If
End While
End Sub
End Class
Przykład 2
W poniższym przykładzie użyto metody , ManualResetEventSlim aby zademonstrować sposób odblokowywania elementów pierwotnych koordynacji, które obsługują ujednolicone anulowanie. Tego samego podejścia można użyć z innymi uproszczonymi elementami pierwotnymi koordynacji, takimi jak SemaphoreSlim
i CountdownEvent.
using System;
using System.Threading;
using System.Threading.Tasks;
class CancelNewStyleEvents
{
// New-style MRESlim that supports unified cancellation
// in its Wait methods.
static ManualResetEventSlim mres = new ManualResetEventSlim(false);
static void Main()
{
var cts = new CancellationTokenSource();
// Pass the same token source to the delegate and to the task instance.
Task.Run(() => DoWork(cts.Token), cts.Token);
Console.WriteLine("Press c to cancel, p to pause, or s to start/restart,");
Console.WriteLine("or any other key to exit.");
// New-style UI thread.
bool goAgain = true;
while (goAgain)
{
char ch = Console.ReadKey(true).KeyChar;
switch (ch)
{
case 'c':
// Token can only be canceled once.
cts.Cancel();
break;
case 'p':
mres.Reset();
break;
case 's':
mres.Set();
break;
default:
goAgain = false;
break;
}
Thread.Sleep(100);
}
cts.Dispose();
}
static void DoWork(CancellationToken token)
{
while (true)
{
if (token.IsCancellationRequested)
{
Console.WriteLine("Canceled while running.");
token.ThrowIfCancellationRequested();
}
// Wait on the event to be signaled
// or the token to be canceled,
// whichever comes first. The token
// will throw an exception if it is canceled
// while the thread is waiting on the event.
try
{
// mres is a ManualResetEventSlim
mres.Wait(token);
}
catch (OperationCanceledException)
{
// Throw immediately to be responsive. The
// alternative is to do one more item of work,
// and throw on next iteration, because
// IsCancellationRequested will be true.
Console.WriteLine("The wait operation was canceled.");
throw;
}
Console.Write("Working...");
// Simulating work.
Thread.SpinWait(500000);
}
}
}
Imports System.Threading
Imports System.Threading.Tasks
Class CancelNewStyleEvents
' New-style MRESlim that supports unified cancellation
' in its Wait methods.
Shared mres As ManualResetEventSlim = New ManualResetEventSlim(False)
Shared Sub Main10()
Dim cts As New CancellationTokenSource()
' Pass the same token source to the delegate and to the task instance.
Task.Run(Sub() DoWork(cts.Token), cts.Token)
Console.WriteLine("Press c to cancel, p to pause, or s to start/restart,")
Console.WriteLine("or any other key to exit.")
' New-style UI thread.
Dim goAgain As Boolean = True
While goAgain = True
Dim ch As Char = Console.ReadKey(True).KeyChar
Select Case ch
Case "c"c
' Token can only be canceled once.
cts.Cancel()
Case "p"c
mres.Reset()
Case "s"c
mres.Set()
Case Else
goAgain = False
End Select
Thread.Sleep(100)
End While
cts.Dispose()
End Sub
Shared Sub DoWork(ByVal token As CancellationToken)
While True
If token.IsCancellationRequested Then
Console.WriteLine("Canceled while running.")
token.ThrowIfCancellationRequested()
End If
' Wait on the event to be signaled
' or the token to be canceled,
' whichever comes first. The token
' will throw an exception if it is canceled
' while the thread is waiting on the event.
Try
' mres is a ManualResetEventSlim
mres.Wait(token)
Catch e As OperationCanceledException
' Throw immediately to be responsive. The
' alternative is to do one more item of work,
' and throw on next iteration, because
' IsCancellationRequested will be true.
Console.WriteLine("Canceled while waiting.")
Throw
End Try
' Simulating work.
Console.Write("Working...")
Thread.SpinWait(500000)
End While
End Sub
End Class