C#预微处理器指令

1.#define指令定义了一个标识符及一个字符序列(即字符集合)。在源程序中每次遇到该标识符时,就用定义的字符序列替换它。标识符被称为宏名,替换过程称为宏替换,指令的一般形式为:

预处理器指令从来不会转化为可执行代码中的命令,但会影响编译过程中的各个方面。

  • C# 预处理器指令

下面对C#中的预编译指令进行介绍:

C#中的预处理器指令

目录

1. #define 和
#undef

2. #if、#elif、#else
和#endif

3. #warning 和
#error

4. #region
和#endregion

5. #line

6. #pragma

 

  C#中有许多名为“预处理器指令”的命令。这些命令从来不会转化为可执行代码中的命令,但会影响编译过程的各个方面。

  例如,使用预处理器指令可以禁止编译器编译代码的某一部分。如果计划发布两个版本的代码,即基本版本和拥有更多功能的企业版本,就可以使用这些预处理器指令。在编译软件的基本版本时,使用预处理器指令可以禁止编译器编译与额外功能相关的代码。

  另外,在编写提供调试信息的代码时,也可以使用预处理器指令。实际上,在销售软件时,一般不希望编译这部分代码。

  预处理器指令的开头都有符号#。

 

  C++开发人员应知道,在C
和C++中预处理器指令非常重要,但是,在C#中,并没有那么多的预处理器指令,它们的使用也不太频繁。C#提供了其他机制来实现许多C++指令的功能,如定制特性。还要注意,C#并没有一个像C++那样的独立预处理器,所谓的预处理器指令实际上是由编译器处理的。

  尽管如此,C#仍保留了一些预处理器指令名称,因为这些命令会让人觉得就是预处理器。

  下面简要介绍预处理器指令的功能。

 

 

            #define  macro-name
 char-sequence

实际应用如:计划发布二个版本的代码,即基本版本和拥有更多功能的企业版本,就可以使用这些预处理器指令;

     虽然编译器没有单独的预处理器,但在处理该节中描述的指令时如同存在一个单独的预处理器;这些指令用于辅助条件编译。
与 C 和 C++
指令不同,不能使用这些指令创建宏。预处理器指令必须是行上的唯一指令。

1.#define和#undef

用法:

      #define DEBUG

      #undef DEBUG

     
#define告诉编译器,我定义了一个DEBUG的一个符号,他类似一个变量,但是它没有具体的值,可以将它看为一个符号而已。#undef就是删除这个符号的定义。如果符号DEBUG没定义过,则#undef不起作用,否则#define不起作用。二者都必须放在源代码之前。二者的顺序看代码的顺序:

      #define DEBUG 

      #undef  DEBUG

     
这样的话,DEBUG是没有定义的,如果二者换个顺序,编译器就认为DEBUG被定义了

1. #define 和 #undef

  #define 的用法如下所示: #define DEBUG 

  它告诉编译器存在给定名称的符号,在本例中是DEBUG。这有点类似于声明一个变量,但这个变量并没有真正的值,只是存在而已。

  这个符号不是实际代码的一部分,而只在编译器编译代码时存在。在C#代码中它没有任何意义。

 

  #undef 正好相反—— 它删除符号的定义: #undef DEBUG 

  如果符号不存在,#undef
就没有任何作用。同样,如果符号已经存在,则#define
也不起作用。必须把#define 和#undef
命令放在C#源文件的开头位置,在声明要编译的任何对象的代码之前。

  #define
本身并没有什么用,但与其他预处理器指令(特别是#if)结合使用时,它的功能就非常强大了。

 

  这里应注意一般C#语法的一些变化。预处理器指令不用分号结束,一般一行上只有一条命令。这是因为对于预处理器指令,C#不再要求命令使用分号进行分隔。如果它遇到一条预处理器指令,就会假定下一条命令在下一行上。

 

 

 

 

2.#error指令强迫编译器停止编译,它主要用于程序调试。#error指令的一般形式为:

另外在编写提供调试信息的代码时,也可以使用预处理器指令。

  • #if

2.#if、#elif、#else、#endif

      这个告诉编译器进行编译代码的流程控制。考虑下面代码:

            #if DEBUG

                  Console.Write(“debug”);

            #elif RELEASE

                  Console.Write(“release”);

            #else

                  Console.Write(“other”);

            #endif

     
以上代码就是说如果定义了DEBUG则输出debug,定义了RELEASE,则输出realse,否则输出other。如果定义了DEBUG和REALSE会怎么样呢?各位可以自己试一下。

2. #if、#elif、#else 和#endif

  这些指令告诉编译器是否要编译某个代码块。考虑下面的方法:

图片 1

1 int DoSomeWork(double x)
2 {
3   // do something
4   #if DEBUG
5   Console.WriteLine("x is " + x);
6   #endif
7 }

图片 2

  这段代码会像往常那样编译,但Console.WriteLine 命令包含在#if
子句内。

  这行代码只有在前面的#define 命令定义了符号DEBUG 后才执行。

  当编译器遇到#if
语句后,将先检查相关的符号是否存在,如果符号存在,就编译#if
子句中的代码。否则,编译器会忽略所有的代码,直到遇到匹配的#endif
指令为止。

  一般是在调试时定义符号DEBUG,把与调试相关的代码放在#if
子句中。在完成了调试后,就把#define
语句注释掉,所有的调试代码会奇迹般地消失,可执行文件也会变小,最终用户不会被这些调试信息弄糊涂(显然,要做更多的测试,确保代码在没有定义DEBUG
的情况下也能工作)。

  这项技术在C 和C++编程中十分常见,称为条件编译(conditional
compilation)。

 

  #elif (=else if)和#else 指令可以用在#if
块中,其含义非常直观。也可以嵌套#if 块:

图片 3

#define ENTERPRISE
#define W2K
// further on in the file
#if ENTERPRISE
// do something
#if W2K
// some code that is only relevant to enterprise
// edition running on W2K
#endif
#elif PROFESSIONAL
// do something else
#else
// code for the leaner version
#endif

图片 4

 

与C++中的情况不同,使用#if
不是有条件地编译代码的唯一方式,C#还通过Conditional
特性提供了另一种机制。

 

  #if 和#elif
还支持一组逻辑运算符“!”、“==”、“!=”和“||”。如果符号存在,就被认为是true,否则为false,例如:

1 #if W2K && (ENTERPRISE==false) // if W2K is defined but ENTERPRISE isn't

 

 

 

 

           #error  
error-message

 

     如果 C# 编译器遇到最后面跟有
#endif 指令的 #if
指令,则仅当指定的符号已定义时,它才会编译这两个指令之间的代码。 与 C 和
C++ 不同,您不能对符号赋予数值;C# 中的 #if 语句是
Boolean,仅测试符号是否已定义。

3.#warning、#error

     
通过这两个指定可以告诉编译器,出一个警告还是错误信息。除了错误信息以后,编译将停止。

     
参考下面的代码(C#在Debug状态下自动定义DEBUG标志,但Release状态不会自动定义RELEASE标志):

            #if DEBUG 

                  #warning 现在是Debug状态

            #elif RELEASE

                  #warning 现在是Release状态

            #else

                  #error 并清楚什么状态

            #endif

3. #warning 和 #error

  另两个非常有用的预处理器指令是#warning
和#error,当编译器遇到它们时,会分别产生警告或错误。如果编译器遇到#warning
指令,会给用户显示#warning
指令后面的文本,之后编译继续进行。如果编译器遇到#error
指令,就会给用户显示后面的文本,作为一条编译错误消息,然后会立即退出编译,不会生成IL
代码。

  使用这两条指令可以检查#define 语句是不是做错了什么事,使用#warning
语句可以提醒自己执行某个操作:

1 #if DEBUG && RELEASE
2 #error "You've defined DEBUG and RELEASE simultaneously!"
3 #endif
4 #warning "Don't forget to remove this line before the boss tests the code!"
5 Console.WriteLine("*I hate this job.*");

 

 

 

 

3.#if, #else, #elif, #endif

下面介绍几个常用到的预处理器指令

    • 代码示例

4.#region 和#endregion

      这个两个用来组成代码块。

4. #region 和#endregion

  #region 和#endregion
指令用于把一段代码标记为有给定名称的一个块,如下所示。

1 #region Member Field Declarations
2 int x;
3 double d;
4 Currency balance;
5 #endregion

  这看起来似乎没有什么用,它不影响编译过程。这些指令的优点是它们可以被某些编辑器识别,包括Visual
Studio .NET 编辑器。这些编辑器可以使用这些指令使代码在屏幕上更好地布局。

 

 

 

 

 

           #if   expression

 

#define DEBUG
#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
    }
}

5.#line

     
这个指令可以改变编译器在警告和错误信息中显示的文件名和行号信息,用#line
default把行号恢复为默认的行号。

      #line [ number [“file_name”] | default ]

      number 

            要为源代码文件中后面的行指定的编号。

      “file_name”(可选)

           
希望出现在编译器输出中的文件名。默认情况下,使用源代码文件的实际名称。文件名必须括在双引号
(“”) 中。

      default

            重置文件中的行编号。

      备注:

            #line
可能由生成过程中的自动中间步骤使用。例如,如果中间步骤从原始的源代码文件中移除行,但是您仍希望编译器基于文件中的原始行号生成输出,则可以移除行,然后用
#line 模拟原始行号。

      下面的示例说明如何报告与行号关联的两个警告。#line 200
指令迫使行号为 200(尽管默认值为 #7)。另一行 (#9) 作为默认 #line
指令 的结果跟在通常序列后。

示例1:

      // preprocessor_line.cs
      public class MyClass2
      {
            public static void Main()
            {
                  #line 200
                  int i;       // line 200
                  #line default
                  char c;  // line 9
            }
      }

示例2:

     
下面的示例说明调试器如何忽略代码中的隐藏行。运行此示例时,它将显示三行文本。但是,当设置如示例所示的断点并按
F10
键逐句通过代码时,您将看到调试器忽略了隐藏行。另请注意,即使在隐藏行上设置断点,调试器仍会忽略它。

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

5. #line

  #line
指令可以用于改变编译器在警告和错误信息中显示的文件名和行号信息。这条指令用得并不多。

  如果编写代码时,在把代码发送给编译器前,要使用某些软件包改变输入的代码,就可以使用这个指令,因为这意味着编译器报告的行号或文件名与文件中的行号或编辑的文件名不匹配。

  #line 指令可以用于还原这种匹配。也可以使用语法#line default
把行号还原为默认的行号:

1 #line 164 "Core.cs" // We happen to know this is line 164 in the file
2 // Core.cs, before the intermediate
3 // package mangles it.
4 // later on
5 #line default // restores default line numbering

 

 

 

 

           #elif  expression1

#define 和#undef

  • #else

6.#pragma

      
可以抑制或恢复指定的编译警告。与命令行选项不同,#pragma指令可以在类和方法上执行,对抑制什么警告和抑制的时间进行更精细的控制。

       #pragma warning disable 169
       public class Aclass
       {
               int nFiled;
       }
       #pragma warning restore 169

出处:

======================================================================================

  C#的预处理器指令很容易识别,你看到了#,就能认出它们。

  它和其他的命令有什么区别呢?

  区别在于这些命令从来不会转化为可执行代码的命令,但是会影响编译过程的各个方面。

  它用来做什么呢?

 
当计划发布两个版本的代码的时候。即基本版和拥有更多版本的企业版,就可以用到预处理器指令。

 
在编译基本版的时候,使用预处理指令会禁止编译器编译与额外功能相关的代码。

  另外,在编写提供调试信息的代码时,也可以使用预处理器指令。

  下面介绍预处理器指令的功能:

  #define和#undef

  #define用法:  #define Debug

 
Debug可以看做是声明的一个变量,但此变量没有真正的值,仅存在。

 
#define单独用没什么意义,一般是和#if结合使用。

  #undef用法:  
#undef Debug

 
作用就是删除Debug的定义。如果Debug符号不存在,这条指令就没有任何作用。如果Debug符号存在,则之前的#define就没有作用。 

 
#define与#undef声明必须放在C#源文件的开头位置,即程序集的引用的上方。

 

  #if,#elif,#else和#endif

  下面来看一个例子  

图片 5图片 6View Code

图片 7😉

//#define DebugA
#define DebugB
using System;

namespace MyApplication
{
    class Program
    {
        static void Main(string[] args)
        {
#if DebugA
            Console.WriteLine("Hello DebugA");
#elif DebugB
            Console.WriteLine("Hello DebugB");
#else
            Console.WriteLine("Hello Debugelse");
#endif
        }
    }
}

图片 8😉

图片 9

  #elif(=else if)和#else指令可以用在#if中,和C#中的if,else
if,else含义相同。

 
#if和#elif支持一组逻辑运算符”!”,”==”,”!=”和”||”,如果符号存在,则为true。

  #if DebugB && DebugA  //当Debug与DebugA同时存在才会执行

 

  #warning和#error

 当编译器遇到这两条指令时,会分别产生警告和错误。如果编译器遇到#warning指令,会显示该指令后的文本,之后继续编译。

 
如果遇见#error指令,也会显示指令后面的文本。但会立刻退出编译,不会产生IL代码。(其实和编译器的警告和错误意义相同) 

图片 10图片 11View Code

图片 12😉

        static void Main(string[] args)
        {
#warning "All Right?"
            Console.WriteLine("Contine...");
//#error "All Right?"
//            Console.WriteLine("Contine...");
        }

图片 13😉

图片 14

  下图为放开#error注释:

图片 15

 

  #region和#endregion

 
这两条指令,大家应该非常熟悉,作用就是代码缩进和指定该代码块的名称,使得代码可以更好的布局。详细用法可以参照报表系列的代码。

 

  #line

 
这条指令很少用到。作用就是:如果代码在编译之前,要使用某些软件包改变输入的代码,就可以使用它。

  (其实就是更改代码的行号)

 

  #pragma warning

 
此指令可启用或禁用某些警告。

  用法:  #pragma warning disable warning-list
            #pragma warning restore
warning-list

  例子: 

 

using System;

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

 

 

  #pragma
checksum

 作用是生成源文件的校验和,以帮助调试 ASP.NET
页。

   用法:  #pragma checksum “filename” “{guid}” “checksum
bytes”

              filename”             
 要求监视更改或更新的文件的名称。                               

             
“{guid}”                文件的全局唯一标识符
(GUID)。                               

             
“checksum_bytes”  十六进制数的字符串,表示校验和的字节。必须是偶数位的十六进制数。

                                           奇数位的十六进制数字会导致编译时警告,然后指令被忽略。            

    例子:

图片 16图片 17View Code

图片 18😉

class TestClass
{
    static int Main()
    {
        #pragma checksum "file.cs" "{3673e4ca-6098-4ec1-890f-8fceb2a794a2}" "{012345678AB}" // New checksum
    }
}

图片 19😉

  

出处:

===================================================================================

重要说明:

预处理指令都以#号开头并位于行首前面可以出现空格符。

  1. #define
    DEBUG
  2. #define ISSAY  

图片 20

上面的语句定义了连个个预编译的符号,他的作用域是他所处整个文件,定义符号的语句必须出现在所有代码之前,
否则编译的时候会出现一个异常: 不能在文件的第一个标记之后,定义或取消定义预处理器符号 。我们也可以使用#undef来取消一个符号的定义,来看个例子。

#define DEBUG
#undef DEBUG
#define ISSAY   

using System;   
namespace JustDoIt   
{   
    class Program   
     {   
        static void Main(string[] args)   
         {
             #if DEBUG   
             Console.Write("debug.");
             #endif
             #if ISSAY   
             Console.Write("hello.");
         #else   
             Console.Write("you can say nothing.");
             #endif   

         Console.ReadLine();   
         }   
     }   
}   
//输出:hello  

 

==============================================================================================

C#有许多名为预处理器指令的命令。这些命令从来不会被翻译为可执行代码中的命令,但会影响编译过程的各个方面。例如,预处理器可禁止编译器编译代码的某一部分。如果计划发布两个版本的代码,比如基本版本和企业版本,或者针对不同的.NET
Framework版本进行编码,就可以使用这些指令。在Anthem.NET的代码中我们经常可以看到这种用法。

预处理器指令的开头都有符号#。

注意:

C#中并没有一个像C++那样的独立预处理器,所谓的预处理器指令仍由编译器处理。

下面将对这些指令逐一介绍。

6. #pragma

  #pragma
指令可以抑制或还原指定的编译警告。与命令行选项不同,#pragma
指令可以在类或方法级别执行,对抑制警告的内容和抑制的时间进行更精细的控制。

  下面的例子禁止“字段未使用”警告,然后在编译MyClass 类后还原该警告。

图片 21

1 #pragma warning disable 169
2 public class MyClass
3 {
4   int neverUsedField;
5 }
6 #pragma warning restore 169

图片 22

 

 

感谢大家收看,谢谢亲们了。

 

 

 

 

参考资料:《C#高级编程 第8版》

 

【来自 孤影’Blog: 】

           #endif

用法如:#define debug 

     #else
允许您创建复合条件指令,因此,如果前面的 #if 或(可选)#elif
指令中的任何表达式都不为 true,则编译器将计算 #else 与后面的 #endif
之间的所有代码。

1. #define和#undef

#define可以定义符号。当将符号用作传递给#if指令的表达式时,此表达式的计算结果true。如

#define DEBUG

它告诉编译器存在给定名称的符号,在本例中是DEBUG。这个符号不是实际代码的一部分,只在编译代码时存在。

#undef正好相反,它删除一个符号。

必须把#define和#undef命令放在C#源码的开头,即在要编译的任何代码之前。它不像C++中那样可以定义常数值。

#define本身并无大用,它需要配合#if指令使用。

如下代码:

#define DEBUG
 int DoSw(double x)
 {
 #if DEBUG
 COnsole.WriteLine("x is"+X);
 #edif
 }

 

4.#undef指令取消其后那个前面已定义过的宏名,也就是不定义宏。#undef指令的一般形式为:

DEBUGP这个符号不是实际代码的一部分,可当做一个条件,只是在编译器编译代码时存在,在C#代码中它没有任何意义。

  • #elif

2. #if, #elif, #else和#endif

这些指令告诉编译器是否要编译某个代码块。看下面的方法:

static void PrintVersion()
  {
    #if V3
      Console.WriteLine("Version 3.0");
    #elif V2
      Console.WriteLine("Version 2.0");
    #else
      Console.WriteLine("Version 1.0");
    #endif
  }

 

上面的代码会根据定义的符号来打印不同的版本信息。 这种方式成为条件编译。

注意:

使用#if不是条件编译代码的唯一方式,C#还提供了通过Conditional属性的机制。

#if和#elif还支持一组逻辑运算符!=,==,!=和||
。如果符号存在,符号的值被认为是true,否则为false,如:

#if V3 || (V2 == true) // if 定义了V3或V2符号…

           #undef  macro-name

这二个指令必须放在C#源文件的开头位置,在声明要编译的任何对象的代码之前(即是using的前面)。

     #elif 使您得以创建复合条件指令。
如果前导 #if(C# 参考) 和任何可选前导 #elif
指令表达式的计算结果都不是 true,则将计算 #elif 表达式。 如果 #elif
表达式计算为 true,编译器将计算位于 #elif
和下一个条件指令之间的所有代码。

3. #warning和#error

这也是两个很有用的预处理器指令,编译器遇到它们时,会分别产生警告或错误信息。如果遇到#warning指令,会向用户显示#warning指令后面的文本。实际上,在VS2005中,IDE会直接将信息标识出来:

图片 23

而如果编译器遇到#error,就会立即退出编译,不会产生IL代码。

使用这两个指令可以检查#define是不示做错了什么事,使用#warning可以让自己想起做什么事。

#if DEBUG && RELEASE
 #error "You 've define xxxx!"
 #ednif
 #warning "Don't forgot to removexxxxxx!"
 Console.WriteLine("I have this job");

“ 

5.#line

#define本身并没有什么用,但与其他指令(特别是#IF)结合使用时,功能就非常强了。

  • #endif

4. #region和#endregion

#region和#endregion指令用于把一段代码标记为有指定名称的一个块,如下所示:

#region private methods
  private int x;
  private int y;
  #endregion

 

这两个指令不会影响编译过程。但可以为VS编辑器所识别,从而使得代码显示布局更为清晰。

#include <stdio.h>
#line 100                            
 //reset the line counter
int main()                      
{                                          
//line 100
printf(“%d\n”, __LINE__);    //line
101
return 0;                          
    //line 102
}

 

     #endif 指定以 #if
指令开头的条件指令的结尾。

5. #line

可以用于改变编译器在警告和错误信息中显示的文件的名字和行号信息。如果编写代码时,在把代码发给比编译器前,要使用某些软件包改变键入的代码,玖可以使用者个指令,因为这意味着比编译器的报告的行号或文件名与文件中的行号或编译的文件名不匹配。#line指令可以用于恢复这种匹配也可以使用语法#line
default 把行号恢复默认。

#line 164 “cORE.CS”

#LINE default

#if,#elif,#else,#endif

  • # define

6. #pragma,#pragma warning,#pragma checksum

#pragma:为编译器提供特殊的指令,说明如何编译包含杂注的文件。

#pragma warning:可启用或禁用某些警告。

#pragma checksum:生成源文件的校验和,以帮助调试ASP.NET页。

可以抑制或恢复指定的编译警告。与命令行选项不同,#pragma指令可以在类和方法上执行,对抑制什么警告和抑制的时间进行更精细的控制。

#pragma warning disable 169
 public class Aclass
 {
 int nFiled;
 }

 

#pragma warning restore 169

这些预处理指令详见MSDN:

#if.aspx)

#else.aspx)

#elif.aspx)

#endif.aspx)

#
define.aspx)

#undef.aspx)

#warning.aspx)

#error.aspx)

#line.aspx)

#region.aspx)

#endregion.aspx)

#pragma.aspx)

#pragma
warning.aspx)

#pragma
checksum.aspx)

 

出处:

这些指令告诉编译器是否要编译某个代码块。

     #define 可让您定义符号。
当您将符号用作传递给 #if 指令的表达式时,此表达式的计算结果为
true。不能像在 C 和 C++ 中的通常做法一样,使用 #define
指令来声明常数值。最好是将 C#
中的常数定义为类或结构的静态成员。如果具有多个像这样的常数,可以考虑创建一个单独的“Constants”类来保存这些常数。

// 在完成了调试后可以把这二行代码注释掉。

  • #undef

#define enterprise
#define w2k 
using system;

     #undef
使您可以取消符号的定义,以便通过将该符号用作 #if
指令中的表达式,使表达式的计算结果为 false。

可以使用 #define 指令或 /define
编译器选项定义符号。 在使用任何不是指令的语句之前,必须在文件中使用
#undef 指令。

#if enterprise
            // do
如果上面的enterprise符号存在,则执行这里面的语句,否则会忽略所有代码,直到遇到匹配的#endif指令为止。
    #if w2k
            //do
    #endif
#elif pro
            //do
#else
            //do
#endif

    • 代码示例

 

#undef DEBUG
using System;
class MyClass 
{
    static void Main() 
    {
#if DEBUG
        Console.WriteLine("DEBUG is defined");
#else
        Console.WriteLine("DEBUG is not defined");
#endif
    }
}

#region 和#endregion
指令用于把一段代码标记为有给定名称的一个块,用法较易。

  • #warning

 

     #warning
使您得以从代码的特定位置生成一级警告。#warning
通常用在条件指令中。也可以用 #error生成用户定义的错误。

    • 代码示例
#define DEBUG
class MainClass 
{
    static void Main() 
    {
#if DEBUG
#warning DEBUG is defined
#endif
    }
}
  • #error

     #error
使您可以从代码中的特定位置生成错误。#error 通常用在条件指令中。

    • 代码示例
#define DEBUG
class MainClass 
{
    static void Main() 
    {
#if DEBUG
#error DEBUG is defined
#endif
    }
}
  • #line

     #line
使您可以修改编译器的行号以及(可选)错误和警告的文件名输出。
下面的示例说明如何报告与行号关联的两个警告。 #line 200
指令将行号强制设置为 200(尽管默认行号为 #7),在执行下一条 #line
指令之前,文件名将报告为“Special”。 #line default
指令将行号恢复为默认行号,默认行号对前一条指令重新编号的行进行计数。

    • 代码示例
class MainClass
{
    static void Main()
    {
#line 200 "Special"
        int i;    // CS0168 on line 200
        int j;    // CS0168 on line 201
#line default
        char c;   // CS0168 on line 9
        float f;  // CS0168 on line 10
#line hidden // numbering not affected
        string s; 
        double d; // CS0168 on line 13
    }
}
  • #region

     #region 使您可以在使用 Visual
Studio 代码编辑器的大纲显示功能时指定可展开或折叠的代码块。
在较长的代码文件中,能够折叠或隐藏一个或多个区域会十分便利,这样,您可将精力集中于当前处理的文件部分。 #region
块必须以 #endregion 指令终止。#region 块不能与 #if
块重叠。但是,可以将 #region 块嵌套在 #if 块内,或将 #if 块嵌套在
#region 块内。

    • 代码示例
#region MyClass definition
public class MyClass 
{
    static void Main() 
    {
    }
}
#endregion
  • #endregion

     #endregion 标记 #region
块的结尾。

  • #pragma

     #pragma
为编译器提供特殊的指令,以说明如何编译包含杂注的文件。
这些指令必须是编译器支持的指令。 也就是说,不能使用 #pragma
创建自定义预处理指令。

    • 代码示例
#pragma pragma-name pragma-arguments
  • #pragma warning

     #pragma warning
可启用或禁用某些警告。

    • 代码示例
#pragma warning disable warning-list
#pragma warning restore warning-list
  • #pragma checksum

     生成源文件的校验和,以帮助调试
ASP.NET 页。

    • 代码示例
#pragma checksum "filename" "{guid}" "checksum bytes"

发表评论

电子邮件地址不会被公开。 必填项已用*标注