C#理论 —— 预处理器指令、正则表达式、异常处理_c# regex命名空间

1. 预处理器指令

---

预处理器指令实现编译器在编译开始前对信息进行预处理。所有的预处理器指令都是以#开始。预处理器指令不是语句，所以它们不以分号结束。

与 C/C++ 不同的是，C#中的预处理指令不是用来创建宏的。一个预处理器指令必须是该行上的唯一指令。

C# 中可用的预处理器指令如下：

1.1 #define

#define 用于定义一个新符号，通过使用该符号作为传递给 #if 指令的表达式，表达式将返回 true.

#define PI 
using System;
namespace PreprocessorDAppl
{
    class Program
    {
        static void Main(string[] args)
        {
            #if (PI)
             Console.WriteLine("PI is defined");
            #else
             Console.WriteLine("PI is not defined");
            #endif
             Console.ReadKey();
        }
    }
}
运行结果：
PI is defined
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1.2 #if

#if用来创建一个条件指令。条件指令用于测试符号是否为真。如果为真，编译器会执行 #if 和下一个条件指令之间的代码。一个以 #if 指令开始的条件指令，必须以一个 #endif 指令终止。其运行原理和选择结构相似，#if内也可使用关系运算符和逻辑运算符，常用运算符如下：

• == (等于)
• != (不等于)
• && (与)
• || (或)

#define DEBUG
#define VC_V10
using System;
public class TestClass
{
    public static void Main()
    {

#if (DEBUG && !VC_V10)
         Console.WriteLine("DEBUG is defined");
#elif (!DEBUG && VC_V10)
         Console.WriteLine("VC_V10 is defined");
#elif (DEBUG && VC_V10)
        Console.WriteLine("DEBUG and VC_V10 are defined");
#else
         Console.WriteLine("DEBUG and VC_V10 are not defined");
#endif
        Console.ReadKey();
    }
}
运行结果：
DEBUG and VC_V10 are defined
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

2. 正则表达式

---

正则表达式

正则表达式 是一种匹配输入文本的功能模式。.Net 框架提供了正则表达式引擎。该模式由一个或多个字符、运算符和结构组成。

下面列出了用于定义正则表达式的各种类别的字符、运算符和结构。

2.1 转义字符

正则表达式中的反斜杠字符（\）指示其后跟的字符是特殊字符，或应按原义解释该字符。

2.2 字符类

字符类与一组字符中的任何一个字符匹配。

2.3 定位点

定位点或原子零宽度断言会使匹配成功或失败，具体取决于字符串中的当前位置，但它们不会使引擎在字符串中前进或使用字符。

2.4 分组构造

分组构造描述了正则表达式的子表达式，通常用于捕获输入字符串的子字符串。

这一部分比较难于理解，可以阅读正则表达式-选择、正则表达式的先行断言(lookahead)和后行断言(lookbehind)

using System;
using System.Text.RegularExpressions;

public class Example
{
    public static void Main()
    {
        string input = "1851 1999 1950 1905 2003";
        string pattern = @"(?<=19)\d{2}\b";

        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine(match.Value);

        Console.ReadKey();
    }
}
运行结果：
99
50
05
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.5 限定符

限定符指定在输入字符串中必须存在上一个元素（可以是字符、组或字符类）的多少个实例才能出现匹配项。

2.6 反向引用构造

反向引用允许在同一正则表达式中随后标识以前匹配的子表达式。

2.7 备用构造

备用构造用于修改正则表达式以启用 either/or 匹配。

2.8 替换

替换是替换模式中使用的正则表达式。

2.9 杂项构造

2.10 Regex 类

Regex 类用于表示一个正则表达式。

2.11 例程

• 匹配以 ‘S’ 开头的单词

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
    class Program
    {
        private static void showMatch(string text, string expr)
        {
            Console.WriteLine("The Expression: " + expr);
            MatchCollection mc = Regex.Matches(text, expr); // 在text中以正则表达式expr匹配单词
            foreach (Match m in mc) // 逐次打印匹配结果
            {
                Console.WriteLine(m);
            }
        }
        static void Main(string[] args)
        {
            string str = "A Thousand Splendid Suns";

            Console.WriteLine("Matching words that start with 'S': ");
            showMatch(str, @"\bS\S*");
            Console.ReadKey();
        }
    }
}
运行结果：
Matching words that start with 'S':
The Expression: \bS\S*
Splendid
Suns
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

• 匹配了以 ‘m’ 开头以 ‘e’ 结尾的单词

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
    class Program
    {
        private static void showMatch(string text, string expr)
        {
            Console.WriteLine("The Expression: " + expr);
            MatchCollection mc = Regex.Matches(text, expr); // 在text中以正则表达式expr匹配单词
            foreach (Match m in mc) // 逐次打印匹配结果
            {
                Console.WriteLine(m);
            }
        }
        static void Main(string[] args)
        {
            string str = "make maze and manage to measure it";

            Console.WriteLine("Matching words start with 'm' and ends with 'e':");
            showMatch(str, @"\bm\S*e\b");
            Console.ReadKey();
        }
    }
}
运行结果：
Matching words start with 'm' and ends with 'e':
The Expression: \bm\S*e\b
make
maze
manage
measure
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

• 替换掉多余的空格

using System;
using System.Text.RegularExpressions;

namespace RegExApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            string input = "Hello   World   ";
            string pattern = "\\s+";
            string replacement = " ";
            Regex rgx = new Regex(pattern);
            string result = rgx.Replace(input, replacement);

            Console.WriteLine("Original String: {0}", input);
            Console.WriteLine("Replacement String: {0}", result);
            Console.ReadKey();
        }
    }
}
运行结果：
Original String: Hello   World
Replacement String: Hello World
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3. 异常处理

---

异常是在程序执行期间出现的问题。

C# 异常处理时建立在四个关键词之上的：try、catch、finally 和 throw。

• try：一个 try 块标识了一个将被激活的特定的异常的代码块。后跟一个或多个 catch 块。
• catch：程序通过异常处理程序捕获异常。catch 关键字表示异常的捕获。
• finally：finally 块用于执行给定的语句，不管异常是否被抛出都会执行。例如，如果您打开一个文件，不管是否出现异常文件都要被关闭。
• throw：当问题出现时，程序抛出一个异常。使用 throw 关键字来完成。

假设一个代码块（block）可能出现异常，可使用 try 和 catch 关键字捕获异常。try/catch 块内的代码为受保护的代码，使用 try/catch 语法如下所示：

try
{
   // 可能引起异常的语句
}
catch( ExceptionName e1 ) // 语句运行结果可能引起的异常
{
   // 错误处理代码
}
catch( ExceptionName e2 ) // 语句运行结果可能引起的异常
{
   // 错误处理代码
}
catch( ExceptionName eN ) // 语句运行结果可能引起的异常
{
   // 错误处理代码
}
finally // 异常处理结果，无论是否发生异常，都会运行该语句内容
{
   // 要执行的语句
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.1 C# 中的异常类

C# 异常是使用类来表示的。C# 中的异常类主要是直接或间接地派生于 System.Exception 类。

System.ApplicationException 和 System.SystemException 类就是派生于 System.Exception 类的异常类。

• System.ApplicationException 类支持由应用程序生成的异常。所以程序员定义的异常都应派生自该类。

• System.SystemException 类是所有预定义的系统异常的基类。

下表列出了一些派生自 System.SystemException 类的预定义的异常类：

3.2 异常处理

C# 以 try 和 catch 块的形式提供了一种结构化的异常处理方案。使用这些块，把核心程序语句与错误处理语句分离开。

这些错误处理块是使用 try、catch 和 finally 关键字实现的。

using System;
namespace ErrorHandlingApplication
{
    class DivNumbers
    {
        int result;
        DivNumbers()
        {
            result = 0;
        }
        public void division(int num1, int num2)
        {
            try
            {
                result = num1 / num2;
            }
            catch (DivideByZeroException e) // 捕捉发生除数为零的异常
            {
                Console.WriteLine("Exception caught: {0}", e);
            }
            finally
            {
                Console.WriteLine("Result: {0}", result); // 输出打印结果
            }

        }
        static void Main(string[] args)
        {
            DivNumbers d = new DivNumbers();
            d.division(25, 0); // 使用异常处理
            Console.ReadKey();
        }
    }
}
运行结果：
Exception caught: System.DivideByZeroException: 尝试除以零。
   在 ErrorHandlingApplication.DivNumbers.division(Int32 num1, Int32 num2) 位置 C:\Users\xxx\source\repos\xxx\Program.cs:行号 15
Result: 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

3.3 用户自定义异常

C#允许用户自定义自己的异常。用户自定义的异常类派生自 ApplicationException 类。

using System;
namespace UserDefinedException
{
    class TestTemperature
    {
        static void Main(string[] args)
        {
            Temperature temp = new Temperature();
            try 
            {
                temp.showTemp();
            }
            catch (TempIsZeroException e)  // 捕捉发生的异常
            {
                Console.WriteLine("TempIsZeroException: {0}", e.Message);
            }
            Console.ReadKey();
        }
    }
}
// 用户自定义异常处理函数
public class TempIsZeroException : ApplicationException
{
    public TempIsZeroException(string message) : base(message)
    {
    }
}

public class Temperature
{
    int temperature = 0;
    public void showTemp()
    {
        if (temperature == 0) 
        {
            throw (new TempIsZeroException("Zero Temperature found")); // 若发生异常，则向外抛出
        }
        else
        {
            Console.WriteLine("Temperature: {0}", temperature);
        }
    }
}
运行结果：
TempIsZeroException: Zero Temperature found
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

3.4 抛出对象

如果异常是直接或间接派生自 System.Exception 类，可抛出一个对象。可在 catch 块中使用 throw 语句来抛出当前的对象。

Catch(Exception e)
{
   ...
   Throw e // 抛出异常
}
1
2
3
4
5