Diretivas de pré-processador C#

Diretivas do pré-processador C#

Neste tutorial, aprenderemos sobre Diretivas de pré-processador, diretivas disponíveis em C# e quando, por que e como elas são usadas.

Como o nome justifica, as diretivas de pré-processador são um bloco de instruções que são processadas antes do início da compilação real. As diretivas de pré-processador C# são os comandos para o compilador que afetam o processo de compilação.

Esses comandos especificam quais seções do código compilar ou como lidar com erros e avisos específicos.

A diretiva de pré-processador C# começa com um # (hash) símbolo e todas as diretivas do pré-processador duram uma linha. As diretivas do pré-processador são encerradas por new line em vez de semicolon .

As diretivas de pré-processador disponíveis em C# são:

Diretivas de pré-processador em C#
Diretiva de pré-processador	Descrição	Sintaxe
`#if`	Verifica se uma expressão do pré-processador é verdadeira ou não	#if preprocessor-expression code to compile #endif
`#elif`	Usado junto com `#if` para verificar várias expressões de pré-processador	#if preprocessor-expression-1 code to compile #elif preprocessor-expression-2 code to compile #endif
`#else`	Usado junto com `#if` para criar uma diretiva condicional composta.	#if preprocessor-expression code to compile #elif code to compile #endif
`#endif`	Usado junto com `#if` para indicar o fim de uma diretiva condicional	#if preprocessor-expression code to compile #endif
`#define`	Usado para definir um símbolo	#define SYMBOL
`#undef`	Usado para indefinir um símbolo	#undef SYMBOL
`#warning`	Permite gerar um aviso de nível 1 do nosso código	#warning warning-message
`#error`	Permite gerar erro do nosso código	#error error-message
`#line`	Permite modificar o número da linha do compilador e o nome do arquivo para exibir erros e avisos	#line line-number file-name
`#region`	Permite criar uma região que pode ser expandida ou recolhida ao usar um Editor de código do Visual Studio	#region region-description codes #endregion
`#endregion`	Indica o fim de uma região	#region region-description codes #endregion
`#pragma`	Dá ao compilador instruções especiais para a compilação do arquivo no qual ele aparece.	#pragma pragma-name pragma-arguments

#define diretiva

O #define diretiva nos permite definir um símbolo.
Símbolos que são definidos quando usados junto com #if diretiva será avaliada como verdadeira.
Esses símbolos podem ser usados para especificar condições para compilação.
Sintaxe:
```
#define SYMBOL
```
Por exemplo:
```
#define TESTING
```
Aqui, TESTING é um símbolo.

#undef diretiva

O #undef diretiva nos permite indefinir um símbolo.
Símbolos indefinidos quando usados junto com #if diretiva será avaliada como false.
Sintaxe:
```
#undef SYMBOL
```
Por exemplo:
```
#undef TESTING
```
Aqui, TESTING é um símbolo.

#if diretiva

Os #if diretiva são usadas para testar a expressão do pré-processador.
Uma expressão de pré-processador pode consistir em apenas um símbolo ou uma combinação de símbolos junto com operadores como && (AND), || (OU), ! (NÃO).
#if diretiva é seguida por um #endif diretiva.
Os códigos dentro do #if diretiva é compilada somente se a expressão testada com #if avalia como verdadeiro.

Sintaxe:

#if preprocessor-expression
	code to compile<
#endif

Por exemplo:

#if TESTING
	Console.WriteLine("Currently Testing");
#endif

Exemplo 1:Como usar a diretiva #if?

#define CSHARP

using System;
 
namespace Directive
{
	class ConditionalDirective
	{
		public static void Main(string[] args)
		{
			#if (CSHARP)
				Console.WriteLine("CSHARP is defined");
			#endif
		}
	}
}

Ao executarmos o programa, a saída será:

CSHARP is defined

No programa acima, CSHARP símbolo é definido usando o #define diretiva no início do programa. Dentro do Main() método, #if é usada para testar se CSHARP é verdade ou não. O bloco de código dentro de #if diretiva é compilada somente se CSHARP é definido.

Diretiva #elif

O #elif A diretiva é usada junto com a diretiva #if que nos permite criar uma diretiva condicional composta.
É usado ao testar a expressão de vários pré-processadores.
Os códigos dentro do #elif diretiva é compilada somente se a expressão testada com esse #elif avalia como verdadeiro.

Sintaxe:

#if preprocessor-expression-1
	code to compile
#elif preprocessor-expression-2
	code-to-compile
#endif

Por exemplo:

#if TESTING
	Console.WriteLine("Currently Testing");
#elif TRAINING
	Console.WriteLine("Currently Training");
#endif

Diretiva #else

O #else diretiva é usada junto com #if diretiva.
Se nenhuma das expressões no #if anterior e #elif (se presente) diretivas são verdadeiras, os códigos dentro do #else diretiva será compilada.

Sintaxe:

#if preprocessor-expression-1
	code to compile
#elif preprocessor-expression-2
	code-to-compile
#else
	code-to-compile
#endif

Por exemplo:

#if TESTING
	Console.WriteLine("Currently Testing");
#elif TRAINING
	Console.WriteLine("Currently Training");
#else
	Console.WriteLine("Neither Testing nor Training");
#endif

Diretiva #endif

O #endif diretiva é usada junto com #if diretiva para indicar o fim de #if diretiva.

Sintaxe:

#if preprocessor-expression-1
	code to compile
#endif

Por exemplo:

#if TESTING
	Console.WriteLine("Currently Testing");
#endif

Exemplo 2:Como usar a diretiva condicional (if, elif, else, endif) ?

#define CSHARP
#undef PYTHON
 
using System;
 
namespace Directive
{
	class ConditionalDirective
	{
		static void Main(string[] args)
		{
			#if (CSHARP && PYTHON)
				Console.WriteLine("CSHARP and PYTHON are defined");
			#elif (CSHARP && !PYTHON)
				Console.WriteLine("CSHARP is defined, PYTHON is undefined");
			#elif (!CSHARP && PYTHON)
				Console.WriteLine("PYTHON is defined, CSHARP is undefined");
			#else
				Console.WriteLine("CSHARP and PYTHON are undefined");
			#endif
		}
	}
}

Ao executarmos o programa, a saída será:

CSHARP is defined, PYTHON is undefined

Neste exemplo, podemos ver o uso de #elif e #else diretiva. Essas diretivas são usadas quando há várias condições a serem testadas. Além disso, os símbolos podem ser combinados usando operadores lógicos para formar uma expressão de pré-processador.

#diretiva de aviso

O #warning A diretiva nos permite gerar um aviso de nível um definido pelo usuário a partir de nosso código.
Sintaxe:
```
#warning warning-message
```
Por exemplo:
```
#warning This is a warning message
```

Exemplo 3:como usar a diretiva #warning?

using System;
 
namespace Directives
{
	class WarningDirective
	{
		public static void Main(string[] args)
		{
			#if (!CSHARP)
				#warning CSHARP is undefined
			#endif
			Console.WriteLine("#warning directive example");
		}
	}
}

Ao executarmos o programa, a saída será:

Program.cs(10,26): warning CS1030: #warning: 'CSHARP is undefined' [/home/myuser/csharp/directives-project/directives-project.csproj]
#warning directive example

Depois de executar o programa acima, veremos a saída como acima. O texto representa uma mensagem de aviso. Aqui, estamos gerando uma mensagem de aviso definida pelo usuário usando o #warning diretiva.

Observe que as instruções após o #warning diretiva também são executadas. Isso significa que o #warning A diretiva não encerra o programa, mas apenas lança um aviso.

Diretiva #error

O #error A diretiva nos permite gerar um erro definido pelo usuário a partir de nosso código.
Sintaxe:
```
#error error-message
```
Por exemplo:
```
#error This is an error message
```

Exemplo 4:como usar a diretiva #error?

using System;
 
namespace Directive
{
	class Error
	{
		public static void Main(string[] args)
		{
			#if (!CSHARP)
				#error CSHARP is undefined
			#endif
			Console.WriteLine("#error directive example");
		}
	}
}

Ao executarmos o programa, a saída será:

Program.cs(10,24): error CS1029: #error: 'CSHARP is undefined' [/home/myuser/csharp/directives-project/directives-project.csproj]
The build failed. Please fix the build errors and run again.

Veremos alguns erros, provavelmente como acima. Aqui estamos gerando um erro definido pelo usuário.

Outra coisa a notar aqui é que o programa será encerrado e a linha #error directive example não será impresso como estava no #warning diretiva.

#line diretiva

O #line A diretiva nos permite modificar o número da linha e o nome do arquivo para erros e avisos.
Sintaxe:
```
#line line-number file-name
```
Por exemplo:
```
#line 50 "fakeprogram.cs"
```

Exemplo 5:Como usar a diretiva #line?

using System;
 
namespace Directive
{
	class Error
	{
		public static void Main(string[] args)
		{
			#line 200 "AnotherProgram.cs"
			#warning Actual Warning generated by Program.cs on line 10
		}
	}
}

Ao executarmos o programa, a saída será:

AnotherProgram.cs(200,22): warning CS1030: #warning: 'Actual Warning generated by Program.cs on line 10' [/home/myuser/csh
arp/directive-project/directive-project.csproj]

Salvamos o exemplo acima como Program.cs . O aviso foi realmente gerado em line 10 por Program.cs . Usando o #line diretiva, alteramos o número da linha para 200 e o nome do arquivo para AnotherProgram.cs que gerou o erro.

#region e #endregion diretiva

O #region A diretiva nos permite criar uma região que pode ser expandida ou recolhida ao usar um Editor de código do Visual Studio.
Esta diretiva é usada simplesmente para organizar o código.
O bloco #region não pode se sobrepor a um #if quadra. No entanto, um #region bloco pode ser incluído em um #if bloco e um #if bloco pode se sobrepor a um #region bloquear.
#endregion diretiva indica o fim de um #region bloquear.

Sintaxe:

#region region-description
	codes
#endregion

Exemplo 6:como usar a diretiva #region?

using System;
 
namespace Directive
{
	class Region
	{
		public static void Main(string[] args)
		{
			#region Hello
			Console.WriteLine("Hello");
			Console.WriteLine("Hello");
			Console.WriteLine("Hello");
			Console.WriteLine("Hello");
			Console.WriteLine("Hello");
			#endregion
		}
	}
}

Ao executarmos o programa, a saída será:

Hello
Hello
Hello
Hello
Hello

Diretiva #pragma

O #pragma A diretiva é usada para fornecer ao compilador algumas instruções especiais para a compilação do arquivo no qual ela aparece.
A instrução pode incluir a desativação ou ativação de alguns avisos.
C# suporta dois #pragma instruções:
- #pragma warning :usado para desabilitar ou habilitar avisos
- #pragma checksum :gera somas de verificação para arquivos de origem que serão usados para depuração.
Sintaxe:
```
#pragma pragma-name pragma-arguments
```
Por exemplo:
```
#pragma warning disable
```

Exemplo 7:Como usar a diretiva #pragma?

using System;
 
namespace Directive
{
	class Error
	{
		public static void Main(string[] args)
		{
			#pragma warning disable
			#warning This is a warning 1
			#pragma warning restore
			#warning This is a warning 2
		}
	}
}

Ao executarmos o programa, a saída será:

Program.cs(12,22): warning CS1030: #warning: 'This is a warning 2' [/home/myuser/csharp/directive-project/directive-project.csproj]

Podemos ver que apenas o segundo aviso é exibido na tela de saída.

Isso ocorre porque, inicialmente, desabilitamos todos os avisos antes do primeiro aviso e os restauramos apenas antes do segundo aviso. Esta é a razão pela qual o primeiro aviso foi ocultado.

Também podemos desabilitar o aviso específico em vez de todos os avisos.

Para saber mais sobre #pragma , visite #pragma (referência C#).

Conversão de tipo C# Namespaces na programação C#

Linguagem C