ReliabilityContractAttribute コンストラクタ

.NET Framework クラス ライブラリ リファレンス

ReliabilityContractAttribute コンストラクタ

メモ : このコンストラクタは、.NET Framework version 2.0 で新しく追加されたものです。

指定した Consistency 保証と Cer 値を使用して、ReliabilityContractAttribute クラスの新しいインスタンスを初期化します。

名前空間: System.Runtime.ConstrainedExecution
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

Public Sub New ( _
    consistencyGuarantee As Consistency, _
    cer As Cer _
)

Visual Basic (使用法)

Dim consistencyGuarantee As Consistency
Dim cer As Cer

Dim instance As New ReliabilityContractAttribute(consistencyGuarantee,
 cer)

C#

public ReliabilityContractAttribute (
    Consistency consistencyGuarantee,
    Cer cer
)

C++

public:
ReliabilityContractAttribute (
    Consistency consistencyGuarantee, 
    Cer cer
)

J#

public ReliabilityContractAttribute (
    Consistency consistencyGuarantee, 
    Cer cer
)

JScript

public function ReliabilityContractAttribute
 (
    consistencyGuarantee : Consistency, 
    cer : Cer
)

パラメータ

consistencyGuarantee

Consistency 値の 1 つ。

cer

Cer 値の 1 つ。

使用例

ReliabilityContractAttribute コンストラクタを使用して、制約された実行領域と実行が保証された finally ブロックを作成するコード例を次に示します。

C#

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's 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 startup, 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);
    }
}

プラットフォーム

Windows 98, Windows 2000 SP4, Windows Millennium Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0

参照

関連項目
ReliabilityContractAttribute クラス
ReliabilityContractAttribute メンバ
System.Runtime.ConstrainedExecution 名前空間