Diretivas de pré-processador do C#C# preprocessor directives

Embora o compilador não tenha um pré-processador separado, as diretivas descritas nesta seção são processadas como se houvesse um.Although the compiler doesn't have a separate preprocessor, the directives described in this section are processed as if there were one. Você os usa para ajudar na compilação condicional.You use them to help in conditional compilation. Ao contrário das diretivas C e C++, você não pode usar essas diretivas para criar macros.Unlike C and C++ directives, you can't use these directives to create macros. Uma diretiva de pré-processador deve ser a única instrução em uma linha.A preprocessor directive must be the only instruction on a line.

Contexto anulávelNullable context

A #nullable diretiva de pré-processador define o contexto de anotação anulável e o contexto de aviso anulável.The #nullable preprocessor directive sets the nullable annotation context and nullable warning context. Essa diretiva controla se as anotações anuláveis têm efeito e se são fornecidos avisos de nulidade.This directive controls whether nullable annotations have effect, and whether nullability warnings are given. Cada contexto é desabilitado ou habilitado.Each context is either disabled or enabled.

Ambos os contextos podem ser especificados no nível do projeto (fora do código-fonte do C#).Both contexts can be specified at the project level (outside of C# source code). A #nullable diretiva controla os contextos de anotação e de aviso e tem precedência sobre as configurações de nível de projeto.The #nullable directive controls the annotation and warning contexts and takes precedence over the project-level settings. Uma diretiva define os contextos que ele controla até que outra diretiva o substitua, ou até o final do arquivo de origem.A directive sets the context(s) it controls until another directive overrides it, or until the end of the source file.

O efeito das diretivas é o seguinte:The effect of the directives is as follows:

  • #nullable disable: Define a anotação anulável e contextos de aviso como desabilitado.#nullable disable: Sets the nullable annotation and warning contexts to disabled.
  • #nullable enable: Define a anotação anulável e contextos de aviso como habilitado.#nullable enable: Sets the nullable annotation and warning contexts to enabled.
  • #nullable restore: Restaura os contextos de anotação e de aviso anuláveis para as configurações do projeto.#nullable restore: Restores the nullable annotation and warning contexts to project settings.
  • #nullable disable annotations: Define o contexto de anotação anulável como desabilitado.#nullable disable annotations: Sets the nullable annotation context to disabled.
  • #nullable enable annotations: Define o contexto de anotação anulável como habilitado.#nullable enable annotations: Sets the nullable annotation context to enabled.
  • #nullable restore annotations: Restaura o contexto de anotação anulável para as configurações do projeto.#nullable restore annotations: Restores the nullable annotation context to project settings.
  • #nullable disable warnings: Define o contexto de aviso anulável como desabilitado.#nullable disable warnings: Sets the nullable warning context to disabled.
  • #nullable enable warnings: Define o contexto de aviso anulável como habilitado.#nullable enable warnings: Sets the nullable warning context to enabled.
  • #nullable restore warnings: Restaura o contexto de aviso anulável para as configurações do projeto.#nullable restore warnings: Restores the nullable warning context to project settings.

Compilação condicionalConditional compilation

Você usa quatro diretivas de pré-processador para controlar a compilação condicional:You use four preprocessor directives to control conditional compilation:

  • #if: Abre uma compilação condicional, em que o código será compilado somente se o símbolo especificado for definido.#if: Opens a conditional compilation, where code is compiled only if the specified symbol is defined.
  • #elif: Fecha a compilação condicional anterior e abre uma nova compilação condicional com base em se o símbolo especificado for definido.#elif: Closes the preceding conditional compilation and opens a new conditional compilation based on if the specified symbol is defined.
  • #else: Fecha a compilação condicional anterior e abre uma nova compilação condicional se o símbolo especificado anterior não estiver definido.#else: Closes the preceding conditional compilation and opens a new conditional compilation if the previous specified symbol isn't defined.
  • #endif: Fecha a compilação condicional anterior.#endif: Closes the preceding conditional compilation.

Quando o compilador C# encontra uma #if diretiva, seguido eventualmente por uma #endif diretiva, ele compila o código entre as diretivas somente se o símbolo especificado é definido.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. Ao contrário de C e C++, você não pode atribuir um valor numérico a um símbolo.Unlike C and C++, you can't assign a numeric value to a symbol. A #if instrução em C# é booliana e só testa se o símbolo foi definido ou não.The #if statement in C# is Boolean and only tests whether the symbol has been defined or not. Por exemplo:For example:

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

Você pode usar os operadores == (igualdade) e != (desigualdade) para testar os bool valores true ou false .You can use the operators == (equality) and != (inequality) to test for the bool values true or false. true significa que o símbolo está definido.true means the symbol is defined. A instrução #if DEBUG tem o mesmo significado que #if (DEBUG == true).The statement #if DEBUG has the same meaning as #if (DEBUG == true). Você pode usar os operadores && (e), || (ou)e ! (não) para avaliar se vários símbolos foram definidos.You can use the && (and), || (or), and ! (not) operators to evaluate whether multiple symbols have been defined. Também é possível agrupar os símbolos e operadores com parênteses.You can also group symbols and operators with parentheses.

#if, junto com as #else diretivas,, #elif #endif , #define e #undef permitem que você inclua ou exclua código com base na existência de um ou mais símbolos.#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. A compilação condicional pode ser útil ao compilar código para uma compilação de depuração ou ao compilar para uma configuração específica.Conditional compilation can be useful when compiling code for a debug build or when compiling for a specific configuration.

Uma diretiva condicional que começa com uma #if diretiva deve ser encerrada explicitamente com uma #endif diretiva.A conditional directive beginning with an #if directive must explicitly be terminated with an #endif directive. A diretiva #define permite definir um símbolo.#define lets you define a symbol. Usando o símbolo como a expressão passada para a #if diretiva, a expressão é avaliada como true .By using the symbol as the expression passed to the #if directive, the expression evaluates to true. Você também pode definir um símbolo com a opção de compilador DefineConstants .You can also define a symbol with the DefineConstants compiler option. Você pode desdefinir um símbolo com #undef .You can undefine a symbol with #undef. O escopo de um símbolo criado com #define é o arquivo no qual ele foi definido.The scope of a symbol created with #define is the file in which it was defined. Um símbolo que você define com DefineConstants ou with #define não entra em conflito com uma variável de mesmo nome.A symbol that you define with DefineConstants or with #define doesn't conflict with a variable of the same name. Ou seja, um nome de variável não deve ser passado para uma diretiva de pré-processador, e um símbolo só pode ser avaliado por uma diretiva de pré-processador.That is, a variable name shouldn't be passed to a preprocessor directive, and a symbol can only be evaluated by a preprocessor directive.

O #elif permite criar uma diretiva condicional composta.#elif lets you create a compound conditional directive. A #elif expressão será avaliada se nenhuma das expressões de diretiva precedentes #if ou anteriores, opcional, forem #elif avaliadas como true .The #elif expression will be evaluated if neither the preceding #if nor any preceding, optional, #elif directive expressions evaluate to true. Se uma #elif expressão for avaliada como true , o compilador avaliará todo o código entre o #elif e a próxima diretiva condicional.If an #elif expression evaluates to true, the compiler evaluates all the code between the #elif and the next conditional directive. Por exemplo:For example:

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

#else permite criar uma diretiva condicional composta, de modo que, se nenhuma das expressões nas diretivas precedentes #if ou (opcionais) #elif for avaliada como true , o compilador avaliará todo #else o código entre e o próximo #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) deve ser a próxima diretiva de pré-processador após #else .#endif(#endif) must be the next preprocessor directive after #else.

#endif Especifica o final de uma diretiva condicional, que começou com a #if diretiva.#endif specifies the end of a conditional directive, which began with the #if directive.

O sistema de compilação também reconhece os símbolos de pré-processador predefinidos que representam estruturas de destino diferentes em projetos em estilo SDK.The build system is also aware of predefined preprocessor symbols representing different target frameworks in SDK-style projects. Eles são úteis ao criar aplicativos que podem ter como destino mais de uma versão do .NET.They're useful when creating applications that can target more than one .NET version.

Frameworks de destinoTarget Frameworks SímbolosSymbols
.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 (e .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

Observação

Para projetos tradicionais de estilo não-SDK, você precisa configurar manualmente os símbolos de compilação condicional para as diferentes estruturas de destino no Visual Studio por meio das páginas de propriedades do projeto.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.

Outros símbolos predefinidos incluem as DEBUG TRACE constantes e.Other predefined symbols include the DEBUG and TRACE constants. Para substituir os valores definidos no projeto, use a diretiva #define.You can override the values set for the project using #define. Por exemplo, o símbolo DEBUG é definido automaticamente, de acordo com as propriedades de configuração do build (Modo de Depuração ou Modo de Versão).The DEBUG symbol, for example, is automatically set depending on your build configuration properties ("Debug" or "Release" mode).

O exemplo a seguir mostra como definir um MYTEST símbolo em um arquivo e, em seguida, testar os valores MYTEST dos DEBUG símbolos e.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. A saída desse exemplo depende se você criou o projeto no modo de configuração de depuração ou versão .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
    }
}

O exemplo a seguir mostra como testar várias estruturas de destino para que você possa usar APIs mais recentes, quando possível: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
    }
    //...
}

Definindo símbolosDefining symbols

Você usa as duas diretivas de pré-processador a seguir para definir ou não definir símbolos para compilação condicional:You use the following two preprocessor directives to define or undefine symbols for conditional compilation:

  • #define: Defina um símbolo.#define: Define a symbol.
  • #undef: Desdefina um símbolo.#undef: Undefine a symbol.

Use #define para definir um símbolo.You use #define to define a symbol. Quando você usar o símbolo como a expressão passada para a #if diretiva, a expressão será avaliada como true , como mostra o exemplo a seguir: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

Observação

A diretiva #define não pode ser usada para declarar valores constantes como normalmente é feito em C e C++.The #define directive cannot be used to declare constant values as is typically done in C and C++. As constantes em C# são mais bem definidas como membros estáticos de uma classe ou struct.Constants in C# are best defined as static members of a class or struct. Se você tiver várias dessas constantes, considere criar uma classe "Constantes" separada para guardá-las.If you have several such constants, consider creating a separate "Constants" class to hold them.

Os símbolos podem ser usados para especificar condições para compilação.Symbols can be used to specify conditions for compilation. Você pode testar o símbolo com um #if ou #elif .You can test for the symbol with either #if or #elif. Você também pode usar o ConditionalAttribute para executar uma compilação condicional.You can also use the ConditionalAttribute to perform conditional compilation. Você pode definir um símbolo, mas não pode atribuir um valor a um símbolo.You can define a symbol, but you can't assign a value to a symbol. A diretiva #define deve ser exibida no arquivo antes de usar as instruções que também não são diretivas de pré-processador.The #define directive must appear in the file before you use any instructions that aren't also preprocessor directives. Você também pode definir um símbolo com a opção de compilador DefineConstants .You can also define a symbol with the DefineConstants compiler option. Você pode desdefinir um símbolo com #undef .You can undefine a symbol with #undef.

Definindo regiõesDefining regions

Você pode definir regiões de código que podem ser recolhidas em uma estrutura de tópicos usando as duas diretivas de pré-processador a seguir:You can define regions of code that can be collapsed in an outline using the following two preprocessor directives:

  • #region: Iniciar uma região.#region: Start a region.
  • #endregion: Encerrar uma região.#endregion: End a region.

#region permite especificar um bloco de código que você pode expandir ou recolher ao usar o recurso de estrutura de tópicos do editor de códigos.#region lets you specify a block of code that you can expand or collapse when using the outlining feature of the code editor. Em arquivos de código mais longos, é conveniente recolher ou ocultar uma ou mais regiões para que você possa se concentrar na parte do arquivo no qual você está trabalhando no momento.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. O exemplo a seguir mostra como definir uma região:The following example shows how to define a region:

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

Um #region bloco deve ser encerrado com uma #endregion diretiva.A #region block must be terminated with an #endregion directive. Um #region bloco não pode se sobrepor a um #if bloco.A #region block can't overlap with an #if block. No entanto, um #region bloco pode ser aninhado em um #if bloco e um #if bloco pode ser aninhado em um #region bloco.However, a #region block can be nested in an #if block, and an #if block can be nested in a #region block.

Informações de erro e avisoError and warning information

Você instrui o compilador para gerar erros e avisos do compilador definido pelo usuário e informações de linha de controle usando as seguintes diretivas:You instruct the compiler to generate user-defined compiler errors and warnings, and control line information using the following directives:

  • #error: Gera um erro do compilador com uma mensagem especificada.#error: Generate a compiler error with a specified message.
  • #warning: Gerar um aviso do compilador, com uma mensagem específica.#warning: Generate a compiler warning, with a specific message.
  • #line: Altere o número de linha impresso com mensagens do compilador.#line: Change the line number printed with compiler messages.

#error permite gerar um erro definido pelo usuário CS1029 de um local específico em seu código.#error lets you generate a CS1029 user-defined error from a specific location in your code. Por exemplo:For example:

#error Deprecated code in this method.

Observação

O compilador trata #error version de forma especial e relata um erro de compilador, CS8304, com uma mensagem contendo o compilador e as versões de linguagem usadas.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 permite gerar um aviso do compilador CS1030 de nível um de um local específico no código.#warning lets you generate a CS1030 level one compiler warning from a specific location in your code. Por exemplo:For example:

#warning Deprecated code in this method.

O #line permite modificar o número de linha do compilador e (opcionalmente) a saída do nome de arquivo para erros e avisos.#line lets you modify the compiler's line numbering and (optionally) the file name output for errors and warnings.

O exemplo a seguir mostra como relatar dois avisos associados aos números de linha.The following example shows how to report two warnings associated with line numbers. A diretiva #line 200 força o próximo número de linha a ser 200 (embora o padrão seja #6) e, até a próxima diretiva #line, o nome de arquivo será relatado como "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". A diretiva #line default retorna a numeração de linhas à sua numeração padrão, que conta as linhas que foram renumeradas pela diretiva anterior.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;
    }
}

A compilação produz a saída a seguir: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

A diretiva #line pode ser usada em uma etapa intermediária e automatizada no processo de build.The #line directive might be used in an automated, intermediate step in the build process. Por exemplo, se linhas fossem removidas do arquivo de código-fonte original, mas você ainda deseja que o compilador gere a saída com base na numeração de linha original no arquivo, seria possível remover as linhas e, em seguida, simular a numeração de linha original com #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.

A #line hidden diretiva oculta as linhas sucessivas do depurador, de modo que, quando o desenvolvedor percorre o código, todas as linhas entre a #line hidden e a próxima #line diretiva (supondo que não seja outra #line hidden diretiva) serão percorridas.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. Essa opção também pode ser usada para permitir que o ASP.NET diferencie entre o código gerado pelo computador e definido pelo usuário.This option can also be used to allow ASP.NET to differentiate between user-defined and machine-generated code. Embora ASP.NET seja o principal consumidor desse recurso, é provável que mais geradores de fonte façam uso dele.Although ASP.NET is the primary consumer of this feature, it's likely that more source generators will make use of it.

Uma #line hidden diretiva não afeta os nomes de arquivo ou números de linha no relatório de erros.A #line hidden directive doesn't affect file names or line numbers in error reporting. Ou seja, se o compilador encontrar um erro em um bloco oculto, o compilador relatará o nome de arquivo atual e o número de linha do erro.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.

A diretiva #line filename especifica o nome de arquivo que você deseja que seja exibido na saída do compilador.The #line filename directive specifies the file name you want to appear in the compiler output. Por padrão, é usado o nome real do arquivo de código-fonte.By default, the actual name of the source code file is used. O nome de arquivo deve estar entre aspas duplas ("") e deve ser precedido por um número de linha.The file name must be in double quotation marks ("") and must be preceded by a line number.

O exemplo a seguir mostra como o depurador ignora as linhas ocultas no código.The following example shows how the debugger ignores the hidden lines in the code. Quando você executar o exemplo, ele exibirá três linhas de texto.When you run the example, it will display three lines of text. No entanto, quando você define um ponto de interrupção, como mostrado no exemplo, e pressiona F10 para percorrer o código, o depurador ignora a linha oculta.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. Mesmo se você definir um ponto de interrupção na linha oculta, o depurador ainda irá ignorá-lo.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.");
    }
}

PragmasPragmas

O #pragma fornece ao compilador instruções especiais para a compilação do arquivo no qual ele é exibido.#pragma gives the compiler special instructions for the compilation of the file in which it appears. O compilador deve dar suporte às instruções.The instructions must be supported by the compiler. Em outras palavras, você não pode usar o #pragma para criar instruções de pré-processamento personalizadas.In other words, you can't use #pragma to create custom preprocessing instructions.

#pragma pragma-name pragma-arguments

Em que pragma-name é o nome de um pragma reconhecido e pragma-arguments são os argumentos específicos de pragma.Where pragma-name is the name of a recognized pragma and pragma-arguments is the pragma-specific arguments.

#pragma warning#pragma warning

O #pragma warning pode habilitar ou desabilitar determinados avisos.#pragma warning can enable or disable certain warnings.

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

Em que warning-list é uma lista separada por vírgulas de números de aviso.Where warning-list is a comma-separated list of warning numbers. O prefixo "CS" é opcional.The "CS" prefix is optional. Quando não houver números de aviso especificados, o disable desabilita todos os avisos e o restore habilita todos os avisos.When no warning numbers are specified, disable disables all warnings and restore enables all warnings.

Observação

Para localizar números de aviso no Visual Studio, compile o projeto e, em seguida, procure os números de aviso na janela de Saída.To find warning numbers in Visual Studio, build your project and then look for the warning numbers in the Output window.

O disable entra em vigor a partir da próxima linha do arquivo de origem.The disable takes effect beginning on the next line of the source file. O aviso é restaurado na linha após o restore .The warning is restored on the line following the restore. Se não houver restore no arquivo, os avisos serão restaurados para seu estado padrão na primeira linha de todos os arquivos posteriores na mesma compilação.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

Gera somas de verificação para os arquivos de origem para ajudar na depuração de páginas do ASP.NET.Generates checksums for source files to aid with debugging ASP.NET pages.

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

Em que "filename" é o nome do arquivo que requer monitoramento de alterações ou atualizações, "{guid}" é o GUID (identificador global exclusivo) para o algoritmo de hash e "checksum_bytes" é a cadeia de caracteres hexadecimais que representa os bytes da soma de verificação.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. Deve ser um número par de dígitos hexadecimais.Must be an even number of hexadecimal digits. Um número ímpar de dígitos resulta em um aviso de tempo de compilação e a diretiva é ignorada.An odd number of digits results in a compile-time warning, and the directive is ignored.

O depurador do Visual Studio usa uma soma de verificação para certificar-se de sempre encontrar a fonte correta.The Visual Studio debugger uses a checksum to make sure that it always finds the right source. O compilador calcula a soma de verificação para um arquivo de origem e, em seguida, emite a saída no arquivo PDB (banco de dados do programa).The compiler computes the checksum for a source file, and then emits the output to the program database (PDB) file. Em seguida, o depurador usa o PDB para comparar com a soma de verificação que ele calcula para o arquivo de origem.The debugger then uses the PDB to compare against the checksum that it computes for the source file.

Essa solução não funciona para projetos ASP.NET, pois a soma de verificação calculada é para o arquivo de origem gerado, em vez do arquivo. 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. Para resolver esse problema, a #pragma checksum fornece suporte à soma de verificação para páginas do ASP.NET.To address this problem, #pragma checksum provides checksum support for ASP.NET pages.

Quando você cria um projeto do ASP.NET em Visual C#, o arquivo de origem gerado contém uma soma de verificação para o arquivo .aspx, do qual a fonte é gerada.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. Então, o compilador grava essas informações no arquivo PDB.The compiler then writes this information into the PDB file.

Se o compilador não encontrar uma #pragma checksum diretiva no arquivo, ele calculará a soma de verificação e gravará o valor no arquivo 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
    }
}