ReliabilityContractAttribute(Consistency, Cer) Construtor
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Inicializa uma nova instância da classe ReliabilityContractAttribute com a garantia Consistency e o valor Cer especificados.
public:
ReliabilityContractAttribute(System::Runtime::ConstrainedExecution::Consistency consistencyGuarantee, System::Runtime::ConstrainedExecution::Cer cer);
public ReliabilityContractAttribute (System.Runtime.ConstrainedExecution.Consistency consistencyGuarantee, System.Runtime.ConstrainedExecution.Cer cer);
new System.Runtime.ConstrainedExecution.ReliabilityContractAttribute : System.Runtime.ConstrainedExecution.Consistency * System.Runtime.ConstrainedExecution.Cer -> System.Runtime.ConstrainedExecution.ReliabilityContractAttribute
Public Sub New (consistencyGuarantee As Consistency, cer As Cer)
- consistencyGuarantee
- Consistency
Um dos valores de Consistency.
O exemplo de código a seguir demonstra o uso do ReliabilityContractAttribute construtor para criar uma região de execução restrita e um finally
bloco que tem a garantia de ser executado.
using System;
using System.Threading;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
// Demonstrate CERs using abrupt thread aborts. Demonstrate there
// is always a finally invocation for any CER that is entered.
class AbruptThreadAbort
{
public static int Main(String[] args)
{
// Run the test a few times--it is timing dependent. The argument
// passed in is the stack depth to create.
for (int i = 0; i < 1000; i++)
if (!Test(i % 5))
{
Console.WriteLine("Failed");
return 0;
}
Console.WriteLine("Succeeded");
return 100;
}
// Create a thread and tell it to create a stack of the required depth.
// The first 3 levels will contain CERs, those after will not. Wait for
// the thread to start up, but abort it immediately. The thread may be
// in the process of setting the stack up at the point the abort occurs.
// Check a state variable after the thread exits to determine if there is
// a consistent state following the abort. Each level of the stack with a
// CER maintains a consistency variable that is reset on entry to the try
// and set in the corresponding finally block. None of these variables
// should be in a reset state after aborting the thread.
static bool Test(int d)
{
// Create the context for the thread. This sets the stack depth for
// the thread and gives the final consistency state after the abort.
WorkUnit wu = new WorkUnit(d);
// Create and start the thread.
Thread t = new Thread(new ThreadStart(wu.StackDepth1));
t.Start();
// Wait until the thread is ready to begin.
wu.wait.WaitOne();
// Abort immediately. This will occassionally interrupt the thread
// as it is setting up the stack, which is good.
t.Abort();
// Wait for the thread to exit.
t.Join();
// Check the final state for consistency.
return wu.consistentLevel1;
}
}
// Context class for the thread worker.
class WorkUnit
{
public EventWaitHandle wait;
public bool consistentLevel1;
public bool consistentLevel2;
public bool consistentLevel3;
public int depth;
public WorkUnit(int d)
{
wait = new EventWaitHandle(false, EventResetMode.AutoReset);
depth = d;
}
public void StackDepth1()
{
// Declare the root CER.
RuntimeHelpers.PrepareConstrainedRegions();
try
{
// Cannot be interrupted until the event set below, so set up
// for initial success. Level 1 consistency is achieved by
// executing the finally; the other two levels are assumed
// consistent.
consistentLevel1 = false;
consistentLevel2 = true;
consistentLevel3 = true;
// Signal the parent thread. From this point on, the thread
// can be aborted.
wait.Set();
// Halt now if we want a one-level stack.
if (depth == 1)
Thread.Sleep(-1);
// Else move to the next level.
StackDepth2();
}
finally
{
// We should always get here. Compute consistency based on
// all the levels.
consistentLevel1 = consistentLevel2 && consistentLevel3;
}
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
[MethodImpl(MethodImplOptions.NoInlining)]
void StackDepth2()
{
try
{
consistentLevel2 = false;
if (depth == 2)
Thread.Sleep(-1);
StackDepth3();
}
finally
{
consistentLevel2 = true;
}
}
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
[MethodImpl(MethodImplOptions.NoInlining)]
void StackDepth3()
{
try
{
consistentLevel3 = false;
if (depth == 3)
Thread.Sleep(-1);
StackDepth4();
}
finally
{
consistentLevel3 = true;
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
void StackDepth4()
{
if (depth == 4)
Thread.Sleep(-1);
StackDepth5();
}
[MethodImpl(MethodImplOptions.NoInlining)]
void StackDepth5()
{
Thread.Sleep(-1);
}
}
Imports System.Threading
Imports System.Runtime.CompilerServices
Imports System.Runtime.ConstrainedExecution
' Demonstrate CERs using abrupt thread aborts. Demonstrate there
' is always a finally invocation for any CER that is entered.
Public Module Example
Public Function Main() As Integer
' Run the test a few times--it is timing dependent. The argument
' passed in is the stack depth to create.
For i As Integer = 0 To 999
If Not Test(i Mod 5)
Console.WriteLine("Failed")
Return 0
End If
Next
Console.WriteLine("Succeeded")
Return 100
End Function
' Create a thread and tell it to create a stack of the required depth.
' The first 3 levels will contain CERs, those after will not. Wait for
' the thread to start up, but abort it immediately. The thread may be
' in the process of setting the stack up at the point the abort occurs.
' Check a state variable after the thread exits to determine if there is
' a consistent state following the abort. Each level of the stack with a
' CER maintains a consistency variable that is reset on entry to the try
' and set in the corresponding finally block. None of these variables
' should be in a reset state after aborting the thread.
Function Test(d As Integer) As Boolean
' Create the context for the thread. This sets the stack depth for
' the thread and gives the final consistency state after the abort.
Dim wu As New WorkUnit(d)
' Create and start the thread.
Dim t As New Thread(AddressOf wu.StackDepth1)
t.Start()
' Wait until the thread is ready to begin.
wu.wait.WaitOne()
' Abort immediately. This will occassionally interrupt the thread
' as it is setting up the stack, which is good.
t.Abort()
' Wait for the thread to exit.
t.Join()
' Check the final state for consistency.
Return wu.consistentLevel1
End Function
End Module
' Context class for the thread worker.
Class WorkUnit
Public wait As EventWaitHandle
Public consistentLevel1 As Boolean
Public consistentLevel2 As Boolean
Public consistentLevel3 As Boolean
Public depth As Integer
Public Sub New(d As Integer)
wait = New EventWaitHandle(False, EventResetMode.AutoReset)
depth = d
End Sub
Public Sub StackDepth1()
' Declare the root CER.
RuntimeHelpers.PrepareConstrainedRegions()
Try
' Cannot be interrupted until the event set below, so set up
' for initial success. Level 1 consistency is achieved by
' executing the finally the other two levels are assumed
' consistent.
consistentLevel1 = False
consistentLevel2 = True
consistentLevel3 = True
' Signal the parent thread. From this point on, the thread
' can be aborted.
wait.Set()
' Halt now if we want a one-level stack.
If depth = 1 Then Thread.Sleep(-1)
' Else move to the next level.
StackDepth2()
Finally
' We should always get here. Compute consistency based on
' all the levels.
consistentLevel1 = consistentLevel2 And consistentLevel3
End Try
End Sub
<ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
<MethodImpl(MethodImplOptions.NoInlining)>
Sub StackDepth2()
Try
consistentLevel2 = False
If depth = 2 Then Thread.Sleep(-1)
StackDepth3()
Finally
consistentLevel2 = True
End Try
End Sub
<ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
<MethodImpl(MethodImplOptions.NoInlining)>
Sub StackDepth3()
Try
consistentLevel3 = False
if depth = 3 Then Thread.Sleep(-1)
StackDepth4()
Finally
consistentLevel3 = True
End Try
End Sub
<MethodImpl(MethodImplOptions.NoInlining)>
Sub StackDepth4()
If depth = 4 Then Thread.Sleep(-1)
StackDepth5()
End Sub
<MethodImpl(MethodImplOptions.NoInlining)>
Sub StackDepth5()
Thread.Sleep(-1)
End Sub
End Class
Produto | Versões |
---|---|
.NET | Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7 |
.NET Framework | 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8 |
.NET Standard | 2.0, 2.1 |