ReliabilityContractAttribute(Consistency, Cer) 建構函式

定義

命名空間:

System.Runtime.ConstrainedExecution

組件:

System.Runtime.dll

來源:

ReliabilityContractAttribute.cs

使用指定的 Consistency 保證和 Cer 值，初始化 ReliabilityContractAttribute 類別的新執行個體。

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

其中一個 Consistency 值。

cer

Cer

其中一個 Cer 值。

範例

下列程式碼範例示範如何使用 ReliabilityContractAttribute 建構函式來建立限制的執列區域，以及 finally 保證要執行的區塊。

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