C# プリプロセッサ ディレクティブC# preprocessor directives

コンパイラに個別のプリプロセッサはありませんが、このセクションに示すディレクティブは、ある場合と同じように処理されます。Although the compiler doesn't have a separate preprocessor, the directives described in this section are processed as if there were one. これらを使用すると、条件付きコンパイルに役立ちます。You use them to help in conditional compilation. C や C++ のディレクティブとは異なり、マクロを作成するのにこれらのディレクティブを使用することはできません。Unlike C and C++ directives, you can't use these directives to create macros. プリプロセッサ ディレクティブは、行の唯一の命令である必要があります。A preprocessor directive must be the only instruction on a line.

Null 許容コンテキストNullable context

#nullable プリプロセッサ ディレクティブは、"Null 許容注釈コンテキスト" と "Null 許容警告コンテキスト" を設定します。The #nullable preprocessor directive sets the nullable annotation context and nullable warning context. このディレクティブでは、Null 許容注釈の効果があるかどうか、および NULL 値の許容の警告が与えられるかどうかが制御されます。This directive controls whether nullable annotations have effect, and whether nullability warnings are given. 各コンテキストは "無効" または "有効" になります。Each context is either disabled or enabled.

どちらのコンテキストもプロジェクト レベル (C# ソース コードの外部) で指定することができます。Both contexts can be specified at the project level (outside of C# source code). #nullable ディレクティブは、注釈と警告のコンテキストを制御し、プロジェクト レベルの設定よりも優先されます。The #nullable directive controls the annotation and warning contexts and takes precedence over the project-level settings. ディレクティブは、別のディレクティブがそれをオーバーライドするか、ソース ファイルの末尾に達するまで、制御するコンテキストを設定します。A directive sets the context(s) it controls until another directive overrides it, or until the end of the source file.

ディレクティブの効果は次のとおりです。The effect of the directives is as follows:

  • #nullable disable: Null 許容注釈および警告コンテキストを "無効" に設定します。#nullable disable: Sets the nullable annotation and warning contexts to disabled.
  • #nullable enable: Null 許容注釈および警告コンテキストを "有効" に設定します。#nullable enable: Sets the nullable annotation and warning contexts to enabled.
  • #nullable restore: Null 許容注釈および警告コンテキストを、プロジェクト設定に復元します。#nullable restore: Restores the nullable annotation and warning contexts to project settings.
  • #nullable disable annotations: Null 許容注釈コンテキストを "無効" に設定します。#nullable disable annotations: Sets the nullable annotation context to disabled.
  • #nullable enable annotations: Null 許容注釈コンテキストを "有効" に設定します。#nullable enable annotations: Sets the nullable annotation context to enabled.
  • #nullable restore annotations: Null 許容注釈コンテキストを、プロジェクト設定に復元します。#nullable restore annotations: Restores the nullable annotation context to project settings.
  • #nullable disable warnings: Null 許容警告コンテキストを "無効" に設定します。#nullable disable warnings: Sets the nullable warning context to disabled.
  • #nullable enable warnings: Null 許容警告コンテキストを "有効" に設定します。#nullable enable warnings: Sets the nullable warning context to enabled.
  • #nullable restore warnings: Null 許容警告コンテキストをプロジェクト設定に復元します。#nullable restore warnings: Restores the nullable warning context to project settings.

条件付きコンパイルConditional compilation

次の 4 つのプリプロセッサ ディレクティブを使用して、条件付きコンパイルを制御します。You use four preprocessor directives to control conditional compilation:

  • #if: 条件付きコンパイルを開きます。コードは、指定されたシンボルが定義されている場合にのみコンパイルされます。#if: Opens a conditional compilation, where code is compiled only if the specified symbol is defined.
  • #elif: 前の条件付きコンパイルを閉じ、指定されたシンボルが定義されているかどうかに基づいて、新しい条件付きコンパイルを開きます。#elif: Closes the preceding conditional compilation and opens a new conditional compilation based on if the specified symbol is defined.
  • #else: 前の条件付きコンパイルを閉じ、前に指定されたシンボルが定義されていない場合は、新しい条件付きコンパイルを開きます。#else: Closes the preceding conditional compilation and opens a new conditional compilation if the previous specified symbol isn't defined.
  • #endif: 前の条件付きコンパイルを閉じます。#endif: Closes the preceding conditional compilation.

C# コンパイラによって、#if ディレクティブ、次いで #endif ディレクティブが検出されると、指定されたシンボルが定義されている場合にのみ、これらのディレクティブ間のコードがコンパイルされます。When the C# compiler finds an #if directive, followed eventually by an #endif directive, it compiles the code between the directives only if the specified symbol is defined. C や C++ とは異なり、シンボルに数値を代入することはできません。Unlike C and C++, you can't assign a numeric value to a symbol. C# の #if ステートメントはブール値で、シンボルが定義されているかどうかのみをテストします。The #if statement in C# is Boolean and only tests whether the symbol has been defined or not. 次に例を示します。For example:

#if DEBUG
    Console.WriteLine("Debug version");
#endif

booltrue または false をテストするために、演算子 == (等式) および != (不等式) を使用することができます。You can use the operators == (equality) and != (inequality) to test for the bool values true or false. true は、シンボルが定義されていることを意味します。true means the symbol is defined. ステートメント #if DEBUG#if (DEBUG == true) の意味は同じです。The statement #if DEBUG has the same meaning as #if (DEBUG == true). && (かつ)|| (または)! (否定) の各演算子を使用すると、複数のシンボルが定義されているかどうかを評価することができます。You can use the && (and), || (or), and ! (not) operators to evaluate whether multiple symbols have been defined. シンボルと演算子は、かっこを使用してグループ化できます。You can also group symbols and operators with parentheses.

#if#else#elif#endif#define#undef の各ディレクティブを組み合わせると、1 つ以上のシンボルが存在するかどうかに応じてコードを含めたり除外したりできます。#if, along with the #else, #elif, #endif, #define, and #undef directives, lets you include or exclude code based on the existence of one or more symbols. 条件付きコンパイルは、デバッグ ビルドのコードをコンパイルする場合や、特定の構成用にコンパイルを行う場合に役立ちます。Conditional compilation can be useful when compiling code for a debug build or when compiling for a specific configuration.

#if ディレクティブで始まる条件付きディレクティブは、#endif ディレクティブで明示的に終了させる必要があります。A conditional directive beginning with an #if directive must explicitly be terminated with an #endif directive. #define を使用するとシンボルを定義できます。#define lets you define a symbol. シンボルを #if ディレクティブに渡す式として使用すると、この式は true と評価されます。By using the symbol as the expression passed to the #if directive, the expression evaluates to true. シンボルは、DefineConstants コンパイラ オプションでも定義できます。You can also define a symbol with the DefineConstants compiler option. #undef を使うと、シンボルを未定義状態にできます。You can undefine a symbol with #undef. #define を使用して作成したシンボルのスコープは、そのシンボルが定義されているファイルです。The scope of a symbol created with #define is the file in which it was defined. DefineConstants または #define で定義したシンボルは、同じ名前の変数とは競合しません。A symbol that you define with DefineConstants or with #define doesn't conflict with a variable of the same name. つまり、変数名をプリプロセッサ ディレクティブに渡すことはできません。シンボルはプリプロセッサ ディレクティブによってのみ評価できます。That is, a variable name shouldn't be passed to a preprocessor directive, and a symbol can only be evaluated by a preprocessor directive.

#elif を使用すると、複合条件付きディレクティブを作成できます。#elif lets you create a compound conditional directive. #elif 式が評価されるのは、前の #if および前の省略可能な #elif ディレクティブ式がいずれも true と評価されなかった場合です。The #elif expression will be evaluated if neither the preceding #if nor any preceding, optional, #elif directive expressions evaluate to true. #elif 式が true と評価された場合は、#elif と次の条件付きディレクティブの間にあるすべてのコードが、コンパイラによって評価されます。If an #elif expression evaluates to true, the compiler evaluates all the code between the #elif and the next conditional directive. 次に例を示します。For example:

#define VC7
//...
#if debug
    Console.WriteLine("Debug build");
#elif VC7
    Console.WriteLine("Visual Studio 7");
#endif

#else を使用すると、複合条件付きディレクティブを作成できるため、前の #if または (省略可能な) #elif ディレクティブの式がいずれも true と評価されない場合は、コンパイラによって #else と次の #endif の間のすべてのコードが評価されます。#else lets you create a compound conditional directive, so that, if none of the expressions in the preceding #if or (optional) #elif directives evaluate to true, the compiler will evaluate all code between #else and the next #endif. #endif(#endif) が、#else の後の次のプリプロセッサ ディレクティブになる必要があります。#endif(#endif) must be the next preprocessor directive after #else.

#endif は、#if ディレクティブで始まる条件付きディレクティブの終了を示します。#endif specifies the end of a conditional directive, which began with the #if directive.

ビルド システムは、SDK 型プロジェクトの各種ターゲット フレームワークを表す、定義済みプリプロセッサ シンボルも認識します。The build system is also aware of predefined preprocessor symbols representing different target frameworks in SDK-style projects. これは、複数の .NET バージョンをターゲットとできるアプリケーションを作成する場合に役立ちます。They're useful when creating applications that can target more than one .NET version.

ターゲット フレームワークTarget Frameworks SymbolsSymbols
.NET Framework.NET Framework NETFRAMEWORK, NET48, NET472, NET471, NET47, NET462, NET461, NET46, NET452, NET451, NET45, NET40, NET35, NET20NETFRAMEWORK, NET48, NET472, NET471, NET47, NET462, NET461, NET46, NET452, NET451, NET45, NET40, NET35, NET20
.NET Standard.NET Standard NETSTANDARD, NETSTANDARD2_1, NETSTANDARD2_0, NETSTANDARD1_6, NETSTANDARD1_5, NETSTANDARD1_4, NETSTANDARD1_3, NETSTANDARD1_2, NETSTANDARD1_1, NETSTANDARD1_0NETSTANDARD, NETSTANDARD2_1, NETSTANDARD2_0, NETSTANDARD1_6, NETSTANDARD1_5, NETSTANDARD1_4, NETSTANDARD1_3, NETSTANDARD1_2, NETSTANDARD1_1, NETSTANDARD1_0
.NET 5 (および .NET Core).NET 5 (and .NET Core) NET, NET5_0, NETCOREAPP, NETCOREAPP3_1, NETCOREAPP3_0, NETCOREAPP2_2, NETCOREAPP2_1, NETCOREAPP2_0, NETCOREAPP1_1, NETCOREAPP1_0NET, NET5_0, NETCOREAPP, NETCOREAPP3_1, NETCOREAPP3_0, NETCOREAPP2_2, NETCOREAPP2_1, NETCOREAPP2_0, NETCOREAPP1_1, NETCOREAPP1_0

注意

従来の非 SDK スタイルのプロジェクトでは、プロジェクトの [プロパティ] ページを使用して、Visual Studio のさまざまなターゲット フレームワークの条件付きコンパイル シンボルを手動で構成する必要があります。For traditional, non-SDK-style projects, you have to manually configure the conditional compilation symbols for the different target frameworks in Visual Studio via the project's properties pages.

他の定義済みシンボルには、DEBUG および TRACE 定数が含まれます。Other predefined symbols include the DEBUG and TRACE constants. #define を使用して、プロジェクトに設定された値をオーバーライドできます。You can override the values set for the project using #define. たとえば、DEBUG シンボルは、ビルド構成プロパティ ("デバッグ" モードまたは "リリース" モード) に応じて自動的に設定されます。The DEBUG symbol, for example, is automatically set depending on your build configuration properties ("Debug" or "Release" mode).

次の例では、ファイルで MYTEST シンボルを定義してから、MYTEST および DEBUG シンボルの値をテストする方法を示します。The following example shows you how to define a MYTEST symbol on a file and then test the values of the MYTEST and DEBUG symbols. この例の出力は、プロジェクトを デバッグリリース のどちらの構成モードでビルドしたかによって異なります。The output of this example depends on whether you built the project on Debug or Release configuration mode.

#define MYTEST
using System;
public class MyClass
{
    static void Main()
    {
#if (DEBUG && !MYTEST)
        Console.WriteLine("DEBUG is defined");
#elif (!DEBUG && MYTEST)
        Console.WriteLine("MYTEST is defined");
#elif (DEBUG && MYTEST)
        Console.WriteLine("DEBUG and MYTEST are defined");  
#else
        Console.WriteLine("DEBUG and MYTEST are not defined");
#endif
    }
}

次の例は、各種ターゲット フレームワークをテストし、可能な場合には新しい API を使用できるようにする方法を示しています。The following example shows you how to test for different target frameworks so you can use newer APIs when possible:

public class MyClass
{
    static void Main()
    {
#if NET40
        WebClient _client = new WebClient();
#else
        HttpClient _client = new HttpClient();
#endif
    }
    //...
}

シンボルの定義Defining symbols

次の 2 つのプリプロセッサ ディレクティブを使用して、条件付きコンパイルのシンボルの定義またはその解除を行います。You use the following two preprocessor directives to define or undefine symbols for conditional compilation:

  • #define: シンボルを定義します。#define: Define a symbol.
  • #undefシンボルの定義を解除します。#undef: undefine a symbol.

#define は、シンボルを定義するために使用します。You use #define to define a symbol. 次の例に示すように、定義したシンボルを式として #if ディレクティブに渡すと、式は true と評価されます。When you use the symbol as the expression that's passed to the #if directive, the expression will evaluate to true, as the following example shows:

#define VERBOSE

#if VERBOSE
   Console.WriteLine("Verbose output version");
#endif

注意

#define ディレクティブを使用して、通常 C および C++ で行うように定数値を宣言することはできません。The #define directive cannot be used to declare constant values as is typically done in C and C++. C# の定数は、クラスまたは構造体の静的メンバーとして定義することができます。Constants in C# are best defined as static members of a class or struct. そのような定数がいくつかある場合は、それを保持するための "Constants" クラスを個別に作成することを検討してください。If you have several such constants, consider creating a separate "Constants" class to hold them.

シンボルを使用して、コンパイル条件を指定できます。Symbols can be used to specify conditions for compilation. シンボルは、#if または #elif で評価できます。You can test for the symbol with either #if or #elif. また、ConditionalAttribute を使用して、条件付きコンパイルを実行することもできます。You can also use the ConditionalAttribute to perform conditional compilation. シンボルを定義することはできますが、シンボルに値を代入することはできません。You can define a symbol, but you can't assign a value to a symbol. #define ディレクティブは、ファイル内で、プリプロセッサ ディレクティブではない他の命令よりも前に記述する必要があります。The #define directive must appear in the file before you use any instructions that aren't also preprocessor directives. シンボルは、DefineConstants コンパイラ オプションでも定義できます。You can also define a symbol with the DefineConstants compiler option. #undef を使うと、シンボルを未定義状態にできます。You can undefine a symbol with #undef.

領域の定義Defining regions

次の 2 つのプリプロセッサ ディレクティブを使用して、アウトラインで折りたたむことができるコードの領域を定義できます。You can define regions of code that can be collapsed in an outline using the following two preprocessor directives:

  • #region: 領域を開始します。#region: Start a region.
  • #endregion: 領域を終了します#endregion: End a region

#region を使用すると、コード ブロックを指定できます。このブロックは、コード エディターのアウトライン機能を使用して、展開や折りたたみを行うことができます。#region lets you specify a block of code that you can expand or collapse when using the outlining feature of the code editor. コード ファイルが長い場合は、現在操作しているファイルの部分に集中できるように 1 つまたは複数の領域を折りたたむ (非表示にする) と便利です。In longer code files, it's convenient to collapse or hide one or more regions so that you can focus on the part of the file that you're currently working on. 次の例では、領域を定義する方法を示します。The following example shows how to define a region:

#region MyClass definition
public class MyClass
{
    static void Main()
    {
    }
}
#endregion

#region ブロックは、#endregion ディレクティブで終了させる必要があります。A #region block must be terminated with an #endregion directive. #region ブロックは、#if ブロックと重複することはできません。A #region block can't overlap with an #if block. しかし、#region ブロックを #if ブロック内に入れ子にしたり、#if ブロックを #region ブロック内に入れ子にしたりすることはできます。However, a #region block can be nested in an #if block, and an #if block can be nested in a #region block.

エラーと警告の情報Error and warning information

次のディレクティブを使用して、ユーザー定義のコンパイラ エラーと警告を生成し、行情報を制御するようにコンパイラに指示します。You instruct the compiler to generate user-defined compiler errors and warnings, and control line information using the following directives:

  • #error: 指定されたメッセージでコンパイラ エラーを生成します。#error: Generate a compiler error with a specified message.
  • #warning: 特定のメッセージでコンパイラ警告を生成します。#warning: Generate a compiler warning, with a specific message.
  • #line: コンパイラ メッセージで出力される行番号を変更します。#line: Change the line number printed with compiler messages.

#error を使用すると、コード内の特定の場所からユーザー定義の CS1029 エラーを生成できます。#error lets you generate a CS1029 user-defined error from a specific location in your code. 次に例を示します。For example:

#error Deprecated code in this method.

注意

コンパイラは #error version を特別な方法で処理し、使用されているコンパイラと言語バージョンを含むメッセージと共にコンパイラ エラー CS8304 を報告します。The compiler treats #error version in a special way and reports a compiler error, CS8304, with a message containing the used compiler and language versions.

#warning を使用すると、コード内の特定の場所から CS1030 レベル 1 のコンパイラの警告を生成できます。#warning lets you generate a CS1030 level one compiler warning from a specific location in your code. 次に例を示します。For example:

#warning Deprecated code in this method.

#line を使用すると、コンパイラの行番号および (必要に応じて) エラーと警告に出力されるファイル名を変更することができます。#line lets you modify the compiler's line numbering and (optionally) the file name output for errors and warnings.

次の例では、行番号に関連付けられている 2 つの警告を報告する方法を示します。The following example shows how to report two warnings associated with line numbers. #line 200 ディレクティブは次の行番号が 200 (既定では #6) になるように強制し、次の #line ディレクティブまでファイル名を "Special" として報告します。The #line 200 directive forces the next line's number to be 200 (although the default is #6), and until the next #line directive, the filename will be reported as "Special". #line default ディレクティブは、行の番号付けをその既定の番号付けに戻します。つまり、前のディレクティブで番号が付け直された行をカウントします。The #line default directive returns the line numbering to its default numbering, which counts the lines that were renumbered by the previous directive.

class MainClass
{
    static void Main()
    {
#line 200 "Special"
        int i;
        int j;
#line default
        char c;
        float f;
#line hidden // numbering not affected
        string s;
        double d;
    }
}

コンパイルで生成される出力は次のとおりです。Compilation produces the following output:

Special(200,13): warning CS0168: The variable 'i' is declared but never used
Special(201,13): warning CS0168: The variable 'j' is declared but never used
MainClass.cs(9,14): warning CS0168: The variable 'c' is declared but never used
MainClass.cs(10,15): warning CS0168: The variable 'f' is declared but never used
MainClass.cs(12,16): warning CS0168: The variable 's' is declared but never used
MainClass.cs(13,16): warning CS0168: The variable 'd' is declared but never used

#line ディレクティブは、ビルド プロセスで自動化された中間ステップで使用される場合があります。The #line directive might be used in an automated, intermediate step in the build process. たとえば、行が元のソース コード ファイルから削除されても、ファイル内の元の行番号付けに基づいてコンパイラに引き続き出力を生成させる場合は、行を削除してから #line を使用して元の行番号付けをシミュレートできます。For example, if lines were removed from the original source code file, but you still wanted the compiler to generate output based on the original line numbering in the file, you could remove lines and then simulate the original line numbering with #line.

開発者がコードをステップ実行すると、#line hidden と次の #line ディレクティブ (別の #line hidden ディレクティブではないと仮定) の間のすべての行がステップ オーバーされるように、#line hidden ディレクティブによって、デバッガーに対して連続する行が非表示にされます。The #line hidden directive hides the successive lines from the debugger, such that when the developer steps through the code, any lines between a #line hidden and the next #line directive (assuming that it isn't another #line hidden directive) will be stepped over. このオプションは、ユーザー定義のコードとコンピューターによって生成されたコードを ASP.NET が区別できるようするために使用することもできます。This option can also be used to allow ASP.NET to differentiate between user-defined and machine-generated code. この機能を主に使われているのは ASP.NET ですが、より多くのソース ジェネレーターで利用できる可能性はあります。Although ASP.NET is the primary consumer of this feature, it's likely that more source generators will make use of it.

#line hidden ディレクティブは、エラー報告でのファイル名や行番号には影響しません。A #line hidden directive doesn't affect file names or line numbers in error reporting. つまり、コンパイラによって非表示のブロックでエラーが検出された場合、そのコンパイラによってエラーの現在のファイル名と行番号が報告されます。That is, if the compiler finds an error in a hidden block, the compiler will report the current file name and line number of the error.

#line filename ディレクティブは、コンパイラ出力に表示するファイル名を指定します。The #line filename directive specifies the file name you want to appear in the compiler output. 既定では、ソース コード ファイルの実際の名前が使用されます。By default, the actual name of the source code file is used. ファイル名は、二重引用符 ("") で囲み、前に行番号を付ける必要があります。The file name must be in double quotation marks ("") and must be preceded by a line number.

次の例では、デバッガーがコード内の非表示の行を無視する方法を示します。The following example shows how the debugger ignores the hidden lines in the code. 例を実行すると、次の 3 行のテキストが表示されます。When you run the example, it will display three lines of text. しかし、例に示されているようにブレークポイントを設定し、F10 キーを押してコードをステップ実行すると、デバッガーで非表示の行が無視されます。However, when you set a break point, as shown in the example, and hit F10 to step through the code, the debugger ignores the hidden line. 非表示の行にブレークポイントを設定した場合でも、デバッガーで引き続きそれが無視されます。Even if you set a break point at the hidden line, the debugger will still ignore it.

// preprocessor_linehidden.cs
using System;
class MainClass
{
    static void Main()
    {
        Console.WriteLine("Normal line #1."); // Set break point here.
#line hidden
        Console.WriteLine("Hidden line.");
#line default
        Console.WriteLine("Normal line #2.");
    }
}

プラグマPragmas

#pragma は、ファイル内に指定され、そのファイルのコンパイルについての特別な命令をコンパイラに指示します。#pragma gives the compiler special instructions for the compilation of the file in which it appears. 命令はコンパイラによってサポートされている必要があります。The instructions must be supported by the compiler. つまり、#pragma を使用してカスタムの前処理命令を作成することはできません。In other words, you can't use #pragma to create custom preprocessing instructions.

#pragma pragma-name pragma-arguments

ここで、pragma-name は認識されているプラグマの名前で、pragma-arguments は pragma 固有の引数です。Where pragma-name is the name of a recognized pragma and pragma-arguments is the pragma-specific arguments.

#pragma 警告#pragma warning

#pragma warning を使用すると、特定の警告を有効または無効にすることができます。#pragma warning can enable or disable certain warnings.

#pragma warning disable warning-list
#pragma warning restore warning-list

ここで、warning-list は警告番号のコンマ区切りのリストです。Where warning-list is a comma-separated list of warning numbers. "CS" というプレフィックスは省略可能です。The "CS" prefix is optional. 警告番号が指定されていないと、disable はすべての警告を無効にし、restore はすべての警告を有効にします。When no warning numbers are specified, disable disables all warnings and restore enables all warnings.

注意

Visual Studio で警告番号を調べるには、プロジェクトをビルドし、[出力] ウィンドウで警告番号を探してください。To find warning numbers in Visual Studio, build your project and then look for the warning numbers in the Output window.

disable は、ソース ファイルの次の行から有効になります。The disable takes effect beginning on the next line of the source file. 警告は、restore の後の行で復元されます。The warning is restored on the line following the restore. ファイルに restore が存在しない場合、警告は、同じコンパイルの以降のファイルの最初の行で既定の状態に復元されます。If there's no restore in the file, the warnings are restored to their default state at the first line of any later files in the same compilation.

// pragma_warning.cs
using System;

#pragma warning disable 414, CS3021
[CLSCompliant(false)]
public class C
{
    int i = 1;
    static void Main()
    {
    }
}
#pragma warning restore CS3021
[CLSCompliant(false)]  // CS3021
public class D
{
    int i = 1;
    public static void F()
    {
    }
}

#pragma checksum#pragma checksum

ASP.NET ページのデバッグに使用するソース ファイルのチェックサムを生成します。Generates checksums for source files to aid with debugging ASP.NET pages.

#pragma checksum "filename" "{guid}" "checksum bytes"

ここで、"filename" は変更または更新の監視を必要とするファイルの名前、"{guid}" はハッシュ アルゴリズムのグローバル一意識別子 (GUID)、"checksum_bytes" はチェックサムのバイト数を表す 16 進数の文字列です。Where "filename" is the name of the file that requires monitoring for changes or updates, "{guid}" is the Globally Unique Identifier (GUID) for the hash algorithm, and "checksum_bytes" is the string of hexadecimal digits representing the bytes of the checksum. 偶数の 16 進数である必要があります。Must be an even number of hexadecimal digits. 奇数の数値を指定すると、コンパイル時に警告が出力され、ディレクティブが無視されます。An odd number of digits results in a compile-time warning, and the directive is ignored.

Visual Studio デバッガーは、常に正しいソースを検出するために、チェックサムを使用します。The Visual Studio debugger uses a checksum to make sure that it always finds the right source. コンパイラはソース ファイルのチェックサムを計算し、プログラム データベース (PDB) ファイルに結果を出力します。The compiler computes the checksum for a source file, and then emits the output to the program database (PDB) file. デバッガーは、その PDB ファイルを使用して、ソース ファイルについて計算したチェックサムと比較します。The debugger then uses the PDB to compare against the checksum that it computes for the source file.

このソリューションは ASP.NET プロジェクトには使用できません。計算されたチェックサムは、.aspx ファイルではなく、生成されたソース ファイルを対象としているためです。This solution doesn't work for ASP.NET projects, because the computed checksum is for the generated source file, rather than the .aspx file. この問題に対応するため、#pragma checksum によって ASP.NET ページのチェックサムがサポートされています。To address this problem, #pragma checksum provides checksum support for ASP.NET pages.

Visual C# で ASP.NET プロジェクトを作成すると、生成されるソース ファイルにソースの生成元である .aspx ファイルのチェックサムが含められます。When you create an ASP.NET project in Visual C#, the generated source file contains a checksum for the .aspx file, from which the source is generated. コンパイラは、この情報を PDB ファイルに書き込みます。The compiler then writes this information into the PDB file.

コンパイラによってファイルで #pragma checksum ディレクティブが検出されない場合、チェックサムが計算され、PDB ファイルにその値が書き込まれます。If the compiler doesn't find a #pragma checksum directive in the file, it computes the checksum and writes the value to the PDB file.

class TestClass
{
    static int Main()
    {
        #pragma checksum "file.cs" "{406EA660-64CF-4C82-B6F0-42D48172A799}" "ab007f1d23d9" // New checksum
    }
}