精华内容
下载资源
问答
  • using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace NamespaceTest { class SampleClass { public void SampleMethod() { Co


    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace NamespaceTest
    {
        class SampleClass
        {
            public void SampleMethod()
            {
                Console.WriteLine("SampleMethod indide namespaceTest");
            }
        }
        namespace nestedNamespace
        {
            class SampleClass
            {
                public void SampleMethod()
                {
                    Console.WriteLine("SampleMethod indide nested namespaceTest");
                }
            }
        }
        class Program
        {
            static void Main(string[] args)
            {
                SampleClass outer = new SampleClass();
                outer.SampleMethod();
                NamespaceTest.SampleClass outer2 = new NamespaceTest.SampleClass();
                outer2.SampleMethod();
    
                nestedNamespace.SampleClass inner = new nestedNamespace.SampleClass();
                inner.SampleMethod();
                NamespaceTest.nestedNamespace.SampleClass inner2 = new NamespaceTest.nestedNamespace.SampleClass();
                inner2.SampleMethod();
    
            }
        }
    }




    展开全文
  • 命名空间(Namespace)1.1 定义命名空间1.2 using 关键字1.3 嵌套命名空间2. 预处理器指令2.1 #define2.2 #if3. 正则表达式 1. 命名空间(Namespace) 命名空间存在目是提供一种让一组名称其他名称分隔开。...

    1. 命名空间(Namespace)


    命名空间存在的目是提供一种让一组名称与其他名称分隔开的封装。使得在一个命名空间中声明的类名与另一个命名空间中声明的相同的类名不冲突。

    就像计算机系统中,一个文件夹(目录)中可以包含多个文件夹,每个文件夹中不能有相同的文件名,但不同文件夹中的文件可以重名。

    💡类似地可以用计算机系统文件夹和文件命名来理解命名空间,把不同的命名空间理解为不同的文件夹,命名空间中的类名理解为文件夹中的文件的文件名。
    当需要用到某文件夹中的方法时,先using命名空间,然后使用。相当于先打开相应文件夹,再从中打开目标文件。

    在这里插入图片描述
    就像在C#理论之一中的1.3节提及的,命名空间内包含了类,类中包含了多个方法和属性。

    using System; // 包含System命名空间
    namespace HelloWorldApplication // 命名空间声明,名称默认与工程名相同,当然也可以修改
    {
       class HelloWorld //一个类,类命可与代码文件命不同
       {
          static void Main(string[] args) // 主函数
          {
             /* 我的第一个 C# 程序*/
             Console.WriteLine("Hello World");
             Console.ReadKey();
          }
       }
    }
    

    1.1 定义命名空间

    命名空间的定义是以关键字 namespace 开始,后跟命名空间的名称。

    using System;
    namespace first_space
    {
        class namespace_cl
        {
            public void func()
            {
                Console.WriteLine("Inside first_space");
            }
        }
    }
    namespace second_space
    {
        class namespace_cl
        {
            public void func()
            {
                Console.WriteLine("Inside second_space");
            }
        }
    }
    class TestClass
    {
        static void Main(string[] args)
        {
            first_space.namespace_cl fc = new first_space.namespace_cl(); // 实例化命名空间first_space中的类
            second_space.namespace_cl sc = new second_space.namespace_cl(); // 实例化命名空间second_space中的类,显然类名是相同的,但来自于不同的命名空间
            fc.func();
            sc.func();
            Console.ReadKey();
        }
    }
    

    1.2 using 关键字

    using 关键字表明程序使用的是给定命名空间中的名称。如在程序中使用 System 命名空间,在System 命名空间中定义了类 Console。那么可以运用下列代码:

    Console.WriteLine ("Hello there");
    // 也可以使用完整限定函数名
    using System;
    System.Console.WriteLine("Hello there");
    
    • 自定义命名空间:
    using System;
    using first_space;
    using second_space;
    
    namespace first_space
    {
        class abc
        {
            public void func()
            {
                Console.WriteLine("Inside first_space");
            }
        }
    }
    namespace second_space
    {
        class efg
        {
            public void func()
            {
                Console.WriteLine("Inside second_space");
            }
        }
    }
    class TestClass
    {
        static void Main(string[] args)
        {
            abc fc = new abc();
            efg sc = new efg();
            fc.func();
            sc.func();
            Console.ReadKey();
        }
    }
    运行结果:
    Inside first_space
    Inside second_space
    

    1.3 嵌套命名空间

    命名空间可以嵌套,即可在一个命名空间内定义另一个命名空间。

    using System;
    using SomeNameSpace;
    using SomeNameSpace.Nested;
    
    namespace SomeNameSpace
    {
        public class MyClass
        {
            static void Main()
            {
                Console.WriteLine("In SomeNameSpace");
                Nested.NestedNameSpaceClass.SayHello();
                Console.ReadKey();
            }
        }
    
        // 命名空间内嵌套命名空间
        namespace Nested
        {
            public class NestedNameSpaceClass
            {
                public static void SayHello()
                {
                    Console.WriteLine("In Nested");
                }
            }
        }
    }
    运行结果:
    In SomeNameSpace
    In Nested
    

    2. 预处理器指令


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

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

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

    预处理器指令 描述
    #define 它用于定义一系列成为符号的字符。
    #undef 它用于取消定义符号。
    #if 它用于测试符号是否为真。
    #else 它用于创建复合条件指令,与 #if 一起使用。
    #elif 它用于创建复合条件指令。
    #endif 指定一个条件指令的结束。
    #line 它可以让您修改编译器的行数以及(可选地)输出错误和警告的文件名。
    #error 它允许从代码的指定位置生成一个错误。
    #warning 它允许从代码的指定位置生成一级警告。
    #region 它可以让您在使用 Visual Studio Code Editor 的大纲特性时,指定一个可展开或折叠的代码块。
    #endregion 它标识着 #region 块的结束。

    2.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
    

    2.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
    

    3. 正则表达式


    正则表达式

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

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

    3.1 转义字符

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

    转义字符 描述 模式 匹配
    \a 与报警 (bell) 符 \u0007 匹配。 \a “Warning!” + ‘\u0007’ 中的 “\u0007”
    \b 在字符类中,与退格键 \u0008 匹配。 [\b]{3,} “\b\b\b\b” 中的 “\b\b\b\b”
    \t 与制表符 \u0009 匹配。 (\w+)\t “Name\tAddr\t” 中的 “Name\t” 和 “Addr\t”
    \r 与回车符 \u000D 匹配。(\r 与换行符 \n 不是等效的。) \r\n(\w+) “\r\nHello\nWorld.” 中的 “\r\nHello”
    \v 与垂直制表符 \u000B 匹配。 [\v]{2,} “\v\v\v” 中的 “\v\v\v”
    \f 与换页符 \u000C 匹配。 [\f]{2,} “\f\f\f” 中的 “\f\f\f”
    \n 与换行符 \u000A 匹配。 \r\n(\w+) “\r\nHello\nWorld.” 中的 “\r\nHello”
    \e 与转义符 \u001B 匹配。 \e “\x001B” 中的 “\x001B”
    \ nnn 使用八进制表示形式指定一个字符(nnn 由二到三位数字组成)。 \w\040\w “a bc d” 中的 “a b” 和 “c d”
    \x nn 使用十六进制表示形式指定字符(nn 恰好由两位数字组成)。 \w\x20\w “a bc d” 中的 “a b” 和 “c d”
    \c X \c x 匹配 X 或 x 指定的 ASCII 控件字符,其中 X 或 x 是控件字符的字母。 \cC “\x0003” 中的 “\x0003” (Ctrl-C)
    \u nnnn 使用十六进制表示形式匹配一个 Unicode 字符(由 nnnn 表示的四位数)。 \w\u0020\w “a bc d” 中的 “a b” 和 “c d”
    \ 在后面带有不识别的转义字符时,与该字符匹配。 \d+[±x*]\d+\d+[±x*\d+ “(2+2) * 39" 中的 “2+2” 和 "39”

    3.2 字符类

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

    字符类 描述 模式 匹配
    [character_group] 匹配 character_group 中的任何单个字符。 默认情况下,匹配区分大小写。 [mn] “mat” 中的 “m”,“moon” 中的 “m” 和 “n”
    [^character_group] 非:与不在 character_group 中的任何单个字符匹配。 默认情况下,character_group 中的字符区分大小写。 [^aei] “avail” 中的 “v” 和 “l”
    [ first - last ] 字符范围:与从 first 到 last 的范围中的任何单个字符匹配。 [b-d] [b-d]irds 可以匹配 Birds、 Cirds、 Dirds
    . 通配符:与除 \n 之外的任何单个字符匹配。 若要匹配原意句点字符(. 或 \u002E),您必须在该字符前面加上转义符 (.)。 a.e “have” 中的 “ave”, “mate” 中的 “ate”
    \p{ name } 与 name 指定的 Unicode 通用类别或命名块中的任何单个字符匹配。 \p{Lu} “City Lights” 中的 “C” 和 “L”
    \P{ name } 与不在 name 指定的 Unicode 通用类别或命名块中的任何单个字符匹配。 \P{Lu} “City” 中的 “i”、 “t” 和 “y”
    \w 与任何单词字符匹配。 \w “Room#1” 中的 “R”、 “o”、 “m” 和 “1”
    \W 与任何非单词字符匹配。 \W “Room#1” 中的 “#”
    \s 与任何空白字符匹配。 \w\s “ID A1.3” 中的 "D "
    \S 与任何非空白字符匹配。 \s\S “int __ctr” 中的 " _"
    \d 与任何十进制数字匹配。 \d “4 = IV” 中的 “4”
    \D 匹配不是十进制数的任意字符。 \D “4 = IV” 中的 " "、 “=”、 " "、 “I” 和 “V”

    3.3 定位点

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

    断言 描述 模式 匹配
    ^ 匹配必须从字符串或一行的开头开始。 ^\d{3} “567-777-” 中的 “567”
    $ 匹配必须出现在字符串的末尾或出现在行或字符串末尾的 \n 之前。 -\d{4}$ “8-12-2012” 中的 “-2012”
    \A 匹配必须出现在字符串的开头。 \A\w{4} “Code-007-” 中的 “Code”
    \Z 匹配必须出现在字符串的末尾或出现在字符串末尾的 \n 之前。 -\d{3}\Z “Bond-901-007” 中的 “-007”
    \z 匹配必须出现在字符串的末尾。 -\d{3}\z “-901-333” 中的 “-333”
    \G 匹配必须出现在上一个匹配结束的地方。 \G(\d) “(1)(3)(5)7” 中的 “(1)”、 “(3)” 和 “(5)”
    \b 匹配一个单词边界,也就是指单词和空格间的位置。 er\b 匹配"never"中的"er",但不能匹配"verb"中的"er"。
    \B 匹配非单词边界。 er\B 匹配"verb"中的"er",但不能匹配"never"中的"er"。

    3.4 分组构造

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

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

    分组构造 描述 模式 匹配
    ( subexpression ) 捕获匹配的子表达式并将其分配到一个从零开始的序号中。 (\w)\1 “deep” 中的 “ee”
    (?< name >subexpression) 将匹配的子表达式捕获到一个命名组中。 (?< double>\w)\k< double> “deep” 中的 “ee”
    (?< name1 -name2 >subexpression) 定义平衡组定义。 (((?‘Open’()[()]*)+((?‘Close-Open’))[()])+)(?(Open)(?!))$ “3+2^((1-3)(3-1))" 中的 "((1-3)(3-1))”
    (?: subexpression) 定义非捕获组。 Write(?:Line)? “Console.WriteLine()” 中的 “WriteLine”
    (?imnsx-imnsx:subexpression) 应用或禁用 subexpression 中指定的选项。 A\d{2}(?i:\w+)\b “A12xl A12XL a12xl” 中的 “A12xl” 和 “A12XL”
    (?= subexpression) 零宽度正预测先行断言。 \w+(?=.) “He is. The dog ran. The sun is out.” 中的 “is”、 “ran” 和 “out”
    (?! subexpression) 零宽度负预测先行断言。 \b(?!un)\w+\b “unsure sure unity used” 中的 “sure” 和 “used”
    (?<=subexpression) 零宽度正回顾后发断言。 (?<=19)\d{2}\b “1851 1999 1950 1905 2003” 中的 “99”、"50"和 “05”
    (?<! subexpression) 零宽度负回顾后发断言。 (?<!wo)man\b “Hi woman Hi man” 中的 “man”
    (?> subexpression) 非回溯(也称为"贪婪")子表达式。 [13579](?>A+B+) “1ABB 3ABBC 5AB 5AC” 中的 “1ABB”、 “3ABB” 和 “5AB”
    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
    

    3.5 限定符

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

    限定符 描述 模式 匹配
    * 匹配上一个元素零次或多次。 \d*.\d “.0”、 “19.9”、 “219.9”
    + 匹配上一个元素一次或多次。 “be+” “been” 中的 “bee”, “bent” 中的 “be”
    ? 匹配上一个元素零次或一次。 “rai?n” “ran”、 “rain”
    { n } 匹配上一个元素恰好 n 次。 “,\d{3}” “1,043.6” 中的 “,043”, “9,876,543,210” 中的 “,876”、 “,543” 和 “,210”
    { n ,} 匹配上一个元素至少 n 次。 “\d{2,}” “166”、 “29”、 “1930”
    { n , m } 匹配上一个元素至少 n 次,但不多于 m 次。 “\d{3,5}” “166”, “17668”, “193024” 中的 “19302”
    *? 匹配上一个元素零次或多次,但次数尽可能少。 \d*?.\d “.0”、 “19.9”、 “219.9”
    +? 匹配上一个元素一次或多次,但次数尽可能少。 “be+?” “been” 中的 “be”, “bent” 中的 “be”
    ?? 匹配上一个元素零次或一次,但次数尽可能少。 “rai??n” “ran”、 “rain”
    { n }? 匹配前导元素恰好 n 次。 “,\d{3}?” “1,043.6” 中的 “,043”, “9,876,543,210” 中的 “,876”、 “,543” 和 “,210”
    { n ,}? 匹配上一个元素至少 n 次,但次数尽可能少。 “\d{2,}?” “166”、 “29” 和 “1930”
    { n , m }? 匹配上一个元素的次数介于 n 和 m 之间,但次数尽可能少。 “\d{3,5}?” “166”, “17668”, “193024” 中的 “193” 和 “024”

    3.6 反向引用构造

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

    反向引用构造 描述 模式 匹配
    \ number 反向引用。 匹配编号子表达式的值。 (\w)\1 “seek” 中的 “ee”
    \k< name > 命名反向引用。 匹配命名表达式的值。 (?< char>\w)\k< char> “seek” 中的 “ee”

    3.7 备用构造

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

    备用构造 描述 模式 匹配
    | 匹配以竖线 (|) 字符分隔的任何一个元素。 th(e|is|at) "this is the day. " 中的 “the” 和 “this”
    (?( expression )yes | no ) 如果正则表达式模式由 expression 匹配指定,则匹配 yes;否则匹配可选的 no 部分。 expression 被解释为零宽度断言。 (?(A)A\d{2}\b|\b\d{3}\b) “A10 C103 910” 中的 “A10” 和 “910”
    (?( name )yes | no ) 如果 name 或已命名或已编号的捕获组具有匹配,则匹配 yes;否则匹配可选的 no。 (?< quoted>")?(?(quoted).+?"|\S+\s) “Dogs.jpg “Yiska playing.jpg”” 中的 Dogs.jpg 和 “Yiska playing.jpg”

    3.8 替换

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

    在这里插入图片描述

    3.9 杂项构造

    构造 描述 实例
    (?imnsx-imnsx) 在模式中间对诸如不区分大小写这样的选项进行设置或禁用。 \bA(?i)b\w+\b 匹配 “ABA Able Act” 中的 “ABA” 和 “Able”
    (?#注释) 内联注释。该注释在第一个右括号处终止。 \bA(?#匹配以A开头的单词)\w+\b
    # [行尾] 该注释以非转义的 # 开头,并继续到行的结尾。 (?x)\bA\w+\b#匹配以 A 开头的单词

    3.10 Regex 类

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

    方法 描述
    public bool IsMatch( string input ) 指示 Regex 构造函数中指定的正则表达式是否在指定的输入字符串中找到匹配项。
    public bool IsMatch( string input, int startat ) 指示 Regex 构造函数中指定的正则表达式是否在指定的输入字符串中找到匹配项,从字符串中指定的开始位置开始。
    public static bool IsMatch( string input, string pattern ) 指示指定的正则表达式是否在指定的输入字符串中找到匹配项。
    public MatchCollection Matches( string input ) 在指定的输入字符串中搜索正则表达式的所有匹配项。
    public string Replace( string input, string replacement ) 在指定的输入字符串中,把所有匹配正则表达式模式的所有匹配的字符串替换为指定的替换字符串。
    public string[] Split( string input ) 把输入字符串分割为子字符串数组,根据在 Regex 构造函数中指定的正则表达式模式定义的位置进行分割。

    3.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
    
    • 匹配了以 ‘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
    
    • 替换掉多余的空格
    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
    

    4. 异常处理


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

    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 // 异常处理结果,无论是否发生异常,都会运行该语句内容
    {
       // 要执行的语句
    }
    

    4.1 C# 中的异常类

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

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

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

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

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

    异常类 描述
    System.IO.IOException 处理 I/O 错误。
    System.IndexOutOfRangeException 处理当方法指向超出范围的数组索引时生成的错误。
    System.ArrayTypeMismatchException 处理当数组类型不匹配时生成的错误。
    System.NullReferenceException 处理当依从一个空对象时生成的错误。
    System.DivideByZeroException 处理当除以零时生成的错误。
    System.InvalidCastException 处理在类型转换期间生成的错误。
    System.OutOfMemoryException 处理空闲内存不足生成的错误。
    System.StackOverflowException 处理栈溢出生成的错误。

    4.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
    

    4.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
    

    4.4 抛出对象

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

    Catch(Exception e)
    {
       ...
       Throw e // 抛出异常
    }
    
    展开全文
  • 命名空间是用来处理程序常见同名冲突,程序设计者可以根据需要指定一些有名字空间域,把一些全局实体分别放在各个命名空间中,从而其他全局实体分割开来。 namespace ns1 { int a; double b; } 命名...

    命名空间是用来处理程序中常见的同名冲突,程序设计者可以根据需要指定一些有名字的空间域,把一些全局实体分别放在各个命名空间中,从而与其他全局实体分割开来。

    namespace ns1
    {
        int a;
        double b;
    }

    命名空间可以嵌套使用;无名的命名空间只在本文件的作用域内有效。

    展开全文
  • C#.NET3.5高级程序设计第四版高清PDF中文完整版

    千次下载 热门讨论 2011-07-05 10:25:50
    4.3 c#中的数组操作  4.4 枚举类型  4.5 结构类型  4.6 值类型和引用类型  4.7 值类型和引用类型:最后的细节  4.8 c#可空类型  4.9 小结  第5章 定义封装的类类型  5.1 c#类类型  5.2 类构造...
  • 第1章 概述 1.1 关于本书 1.2 本书目标 1.3 读者对象 1.4 本书不涉及内容 1.5 必备知识阅读 1.6 补充阅读 1.7 本书组织结构 ...附录D 本书用到的命名空间与前缀 附录E 与本书有关SOAP设计模式
  • 第1章 概述 1.1 关于本书 1.2 本书目标 1.3 读者对象 1.4 本书不涉及内容 1.5 必备知识阅读 1.6 补充阅读 1.7 本书组织结构 ...附录D 本书用到的命名空间与前缀 附录E 与本书有关SOAP设计模式
  • 1.5 库与命名空间 24 1.5.1 库include命令 24 1.5.2 命名空间 25 第2章 流程控制 30 2.1 布尔表达式 30 2.1.1 创建布尔表达式 30 2.1.2 布尔表达式求值 31 2.1.3 优先级原则 33 2.2 分支机制 37 2.2.1 ...
  • 26.3 WF程序集、命名空间和项目 728 26.4 构建一个启用工作流简单应用 730 26.5 WF引擎承载代码 734 26.6 在工作流调用Web服务 736 26.7 构建可重用WF代码库 746 26.8 关于自定义活动简要说明 ...
  • 最后,读者将学习如何创建二维数组以及如何使用嵌套循环来处理它们。 第6章:分支语句和逻辑操作符 如果程序可以根据实际情况调整执行,我们就说程序能够智能地行动。在本章,读者将了解到如何使用if 、if else...
  • 最后,读者将学习如何创建二维数组以及如何使用嵌套循环来处理它们。 第6章:分支语句和逻辑操作符 如果程序可以根据实际情况调整执行,我们就说程序能够智能地行动。在本章,读者将了解到如何使用if 、if else...
  • 最后,读者将学习如何创建二维数组以及如何使用嵌套循环来处理它们。 第6章:分支语句和逻辑操作符 如果程序可以根据实际情况调整执行,我们就说程序能够智能地行动。在本章,读者将了解到如何使用if 、if else...
  • 最后,读者将学习如何创建二维数组以及如何使用嵌套循环来处理它们。 第6章:分支语句和逻辑操作符 如果程序可以根据实际情况调整执行,我们就说程序能够智能地行动。在本章,读者将了解到如何使用if 、if else...
  • 说明: 此参数指定链接程序 (如: UNIX 中的 ld, 或用于将目标文件链接到共享对象或 DLL 的 GNU ld) 的完整路径名。此参数是可选的。随每个平台附带的特有的 make 文件中包含此参数的默认值。如果为此参数指定了一个值...
  • 17.2.7 命名空间与模板 614 17.3 多重继承与虚继承 614 17.3.1 多重继承 615 17.3.2 转换与多个基类 617 17.3.3 多重继承派生类复制控制 619 17.3.4 多重继承下类作用域 620 17.3.5 虚继承 622 17.3.6 虚基类...
  • .NET 数据提供程序实现入门:为定义 .NET 数据提供程序提供信息和建议,其中包括有关可用于实现接口说明和有关为提供程序创建命名空间的信息。 实现连接:描述连接特性,并说明如何为 .NET 数据提供程序实现您...
  • 6.8 差错检测中的概率和算术 31 6.9 校验和检测差错 32 6.10 循环冗余校验检测差错 32 6.11 模块联接 33 6.12 突发错误 34 6.13 帧格式和差错检测机制 34 6.14 小结 35 练习 35 第7章 局域网技术网络拓扑 37 7.1 ...
  • 介绍了在设计框架时最佳实践,提供了自顶向下规范,其中所描述规范普遍适用于规模不同、可重用程度不同框架和软件。这些规范历经.NET框架三个版本长期开发,凝聚了数千名开发人员经验和智慧。微软...
  • 3.5.4 字符数据在内存中的存储形式及使用方法 41 3.5.5 字符串常量 41 3.5.6 符号常量 42 3.6 变量赋初值 42 3.7 各类数值型数据之间的混合运算 43 3.8 算术运算符和算术表达式 44 3.8.1 C运算符简介 44 3.8.2 算术...
  • 内容涉及对象演化、数据抽象、隐藏实现、初始化清除、函数重载缺省参数、输入输出流介绍、常量、内联函数、命名控制、引用和拷贝构造函数、运算符重载、动态对象创建、继承和组合、多态和虚函数、模板和包容器...
  • 3.5.4 字符数据在内存中的存储形式及使用方法 41 3.5.5 字符串常量 41 3.5.6 符号常量 42 3.6 变量赋初值 42 3.7 各类数值型数据之间的混合运算 43 3.8 算术运算符和算术表达式 44 3.8.1 C运算符简介 44 3.8.2 算术...
  • 4.3 C#中的数组操作  4.4 枚举类型  4.5 结构类型  4.6 值类型和引用类型  4.7 值类型和引用类型:最后的细节  4.8 C#可空类型  4.9 小结  第5章 定义封装的类类型  5.1 C#类类型  5.2 类构造...
  • 4.3 C#中的数组操作  4.4 枚举类型  4.5 结构类型  4.6 值类型和引用类型  4.7 值类型和引用类型:最后的细节  4.8 C#可空类型  4.9 小结  第5章 定义封装的类类型  5.1 C#类类型  5.2 类构造...
  • 4.3 C#中的数组操作  4.4 枚举类型  4.5 结构类型  4.6 值类型和引用类型  4.7 值类型和引用类型:最后的细节  4.8 C#可空类型  4.9 小结  第5章 定义封装的类类型  5.1 C#类类型  5.2 类构造...
  • 4.3 C#中的数组操作  4.4 枚举类型  4.5 结构类型  4.6 值类型和引用类型  4.7 值类型和引用类型:最后的细节  4.8 C#可空类型  4.9 小结  第5章 定义封装的类类型  5.1 C#类类型  5.2 类构造...
  • 处理简单XML文件和小型XML文件时,以及在无法生成代码大型,结构不良或深度嵌套的XML文件工作时,它使用都令人愉悦。 它非常适合构建用于单元测试XML结构。 Eaxy很小(<100 kB),没有依赖性。 总...
  • 21天学通C++ (中文第五版)

    热门讨论 2010-06-23 16:57:03
    本书正文及附录D中的范例代码可从Sams网站下载, 其网址为http://www.samspublishing.com。在文本框“Search'’中输入本书英文版的ISBN(0672327112),单击Search按钮,然后单击原版书名(Sams TeachYourselfC++...
  • C++编程思想(中文)

    2011-09-20 17:02:17
    9.1 来自C语言中的静态成员 157 9.1.1 函数内部的静态变量 157 9.1.2 控制连接 160 9.1.3 其他的存储类型指定符 161 9.2 名字空间 161 9.2.1 产生一个名字空间 162 9.2.2 使用名字空间 163 9.3 C++中的静态成员 166 ...
  • 9.1 来自C语言中的静态成员 157 9.1.1 函数内部的静态变量 157 9.1.2 控制连接 160 9.1.3 其他的存储类型指定符 161 9.2 名字空间 161 9.2.1 产生一个名字空间 162 9.2.2 使用名字空间 163 9.3 C++中的静态成员 166 ...

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 367
精华内容 146
关键字:

命名空间与嵌套命名中的处理