第二章-C#基础



(1)引用类型：
     1)同样适用于变量在使用前需初始化
                 实例：
                       创建Something类

```
  Something objSomething;                   -->错
  ---> objSomething = new Something();   
```
(2) 变量作用域
      1）局部变量存在于表示声明该变量的块语句或方法结束的封闭花括号之前。
      2）同名的局部变量不能在同一作用域内声明两次。
      3）C#把声明为类型级的变量看作字段，把在方法中声明的变量看作局部变量。
          实例：
     

```
Class Test2
{
static int j = 20;    //类级变量
public static void Main()
{
int j =30;
Console.WriteLine(j);
return ;
}
}
```
打印出的结果为30.
注意：
1>在含有静态方法的类中，方法中的同名变量会隐藏同名的类级变量。
2>引用类级变量，使用语法object.fieldname，在对象的外部引用类的字段或结构。
访问静态字段：

```
public static void Main()
{
int j =30;
Console.WriteLine(ScopeTest2.j);
}
```
3)访问一个实例字段(该字段属于类的一个特定实例)需使用this关键字。

(3)常量：在初始化变量前加上const，可指定为常量。

```
const int a = 10;
```
1)必须在声明时初始化。
2)从一个变量中提取的值来初始化常量,应使用只读字段。
3)常量总是静态的。

(4)数据类型：分为值类型，和引用类型。
值类型------储存在堆，栈中
1> 包括：枚举类型  ， 数值类型 {int，char，short，int，float },布尔类型。
2>把一个变量赋值给另外一个变量时,拷贝赋值,其中一个变量的值发生改变,对另外一个变量没有影响
3>在栈中分配空间

引用类型----储存在托管的堆上
1>包括：string(属于特殊的引用类型)，类，接口，委托，数组 ，Vector
2>属于同一个内存,互相影响
3>传值时,实参赋给形参，形参值发生改变,实参不变.

1)变量是一个引用，可以把值设置为null，表示不引用任何对象。

```
y = null;
```
2)可使用object引用绑定任何子类型的对象。
3)@+“路径”
4)在字符串字面量中包含换行符：
  

```
string jabberwocky = @" 'skdfdkgkksfjkdf
fdskfjkfjd . ";
打印出的结果为：'skdfdkgkksfjkdffdskfjkfjd .
```

(5)if 语句
1)C#中不能直接测试整数(例如从函数中返回的值)，而必须明确的把返回的整数转换为布尔值true或false。
(6)switch语句
1)switch参数中的表达式的值等于某个case子句旁的某个值，就该执行该case子句中的代码，用break结尾即可。
2)也可以包含一个default子句，若表达式不等任何case子句的值，就执行default子句的代码。
3)case的值必须是常量表达式-----不允许使用变量。

(7)while循环
    在循环开始前，不知道重复执行一个语句或语句块的次数。
(8)do--while
适合于至少执行一次循环体的情况。
(9)foreach ： 每次迭代数组中的一个元素。
(10)go--to语句
1)可以直接跳转到程序中用标签指定的另一行(标签是一个标识符，后跟一个冒号)

```
go to Label1;
Console.WriteLine("......");
Label 1:
Console.WriteLine("$$$$$$$");
```
1>不能跳转到循环体中，也不能跳出类的范围，不能退出try--catch块后面的finally块。
2>在switch语句的case子句之间跳转最方便，但在其他情况下不使用它。

(11)break语句
1)break 语句——在 switch 语句中使用它退出某个 case 语句。
2)break 也可以用于退出 for、 foreach、 while 或 do...while 循环，该语句会使控制流执行循环后面的语句。
3)如果该语句放在嵌套的循环中， 就执行最内部循环后面的语句。
4)如果 break 放在 switch语句或循环外部，就会产生编译错误。

(12)continue 语句
1)类似于 break，也必须在 for、 foreach、 while 或 do...while 循环中使用。
2)只退出循环的当前迭代，开始执行循环的下一次迭代，而不是退出循环。

(13)return 语句
如果方法有返回类型，return 语句必须返回这个类型的值，如果方法没有返回类型，应使用没有表达式的 return语句。

(14)枚举
定义枚举：

```
//默认的访问修饰符为private
//定义：enum 枚举名｛成员变量。。。｝
public enum TimeOfDay
{
Morning = 0,
Afternoon = 1,
Evening = 2
}

/* 把枚举值传送给方法 */
public static int Main()
{
WriteGreeting(TimeOfDay.Morning);
return 0;
}


/*在 switch 语句中迭代可能的值。 */

switch(timeOfDay)
{
case TimeOfDay.Morning:
Console.WriteLine("Good morning!");
break;
case TimeOfDay.Afternoon:
Console.WriteLine("Good afternoon!");
break;
case TimeOfDay.Evening:
Console.WriteLine("Good evening!");
break;
default:
Console.WriteLine("Hello!");
break;
}

//用字符串表示获取的枚举值
TimeOfDay time = TimeOfDay.Afternoon;
Console.WriteLine(time.ToString());
打印出结果为：Afternoon。

//从字符串中获取枚举值：
TimeOfDay time2 = (TimeOfDay)Enum.Parse(typeof(TimeOfDay),    
                  "afternoon", true);
Console.WriteLine((int)time2);

打印出的结果为：1
注意：
1>从字符串获取枚举值，并转换为整数。需要使用静态的 Enum.Parse()方法
2>方法带3个参数，第一个参数是要使用的枚举类型，其语法是关键字typeof后跟放在括号中的枚举类名.第二个参数是要转换的字符串，第三个参数是一个 bool.

3> Enum.Parse()方法实际上返回一个对象引用需要把这个字符串显式转换为需要的枚举类型。将返回 1，作为一个对象，对应于 TimeOfDay.fternoon 的枚举值。在显式转换为 int 时，会再次生成 1。

```

(15)数组
1)初始化特定大小的数组，可以使用 new 关键字，在类型名后面的方括号中给出数组的大小：

```
int[] integers = new int[32];
```

2)所有的数组都是引用类型，因此，即使各个元素都是基本的值类型， integers 数组也是引用类型。

```
int[] copy = integers;
该代码也只是把变量 copy 指向同一个数组，而不是创建一个新数组。
```
1>访问数组中的单个元素，在数组名的后面，把元素的下标放在方括号中。

```
integers[0] = 35;
integers[31] = 432;
```
2>数组下标从0开始，至数组长度-1。

3)C#可以在声明数组时不进行初始化，就可以在程序中动态地指定其大小。可以创建一个空引用，以后再使用 new关键字把这个引用指向请求动态分配的内存位置：

```
int[] integers;
integers = new int[32];
```
1>使用下面的语法查看数组包৿多少个元素：

```
int numElements = integers.Length;
```

(16)命名空间
1)命名空间是一种逻辑组合，定义类时，可以把它包括在命名空间定义中。在定义另一个类，在另一个文件中执行相关操作时，就可以在同一个
命名空间中包含并使用它。
1>有相同短名的不同的类就可以在同一个程序中使用了。
2>不允许在另一个嵌套的命名空间中声明多部分的命名空间。
3>同一个程序集中可以有不同的命名空间，也可以在不同的程序集中定义同一个命名空间中的类型。

(17)Main方法
1)给Main方法传参数
---传递一个数组参数，args

```
using System;
namespace Wrox.ProCSharp.Basics
{
class ArgsExample
{
public static int Main(string[] args)
{
for (int i = 0; i < args.Length; i++)
{
Console.WriteLine(args[i]);
}
return 0;
}
}
}
```
打印出的结果：

```
/a
/b
/c
```

(18)csc.exe扩展
1)编译其他程序：使用/target 选项(常简写为/t)来指定要创建的文件类型。

```
              表 2-8
选 项                   输 出
/t:exe            控制台应用程序 (默认)
/t:library        带有清单的类库
/t:module         没有清单的组件
/t:winexe         Windows 应用程序 (没有控制台窗口)
```

```
namespace Wrox.ProCSharp.Basics
{
public class MathLib
{
public int Add(int x, int y)
{
return x + y;
}
}
}
```
使用下述命令把这个 C#文件编译为. NET DLL：
csc /t:library MathLibrary.cs

控制台应用程序 MathClient.cs 将简单地实例化这个对象，调用其 Add 方法，在控制台窗口中显示结果：

```
using System;
namespace Wrox.ProCSharp.Basics
{
class Client
{
public static void Main()
{
MathLib mathObj = new MathLib();
Console.WriteLine(mathObj.Add(7,8));
}
}
}
```
使用/r 选项编译这个文件，使之指向新编译的 DLL：
csc MathClient.cs /r:MathLibrary.dll

命令提示符上输入 MathClient，其结果是显示数字 15—— 加运算的结果。


(19)XML文档说明
1)以 3 个斜杠(///)开头，在这些注释中，可以把包৿类型和类型成员的文档说明的 XML 标识符放在代码中。

```
                表 2-10
标 识                       符 说 明
<c>             把行中的文本标记为代码，例如<c>int i = 10;</c>
<code>          把多行标记为代码
<example>       标记为一个代码示例
<exception>     说明一个异常类(编译器要验证其语法)
<include>       包含其他文档说明文件的注释(编译器要验证其语法)
<list>          把列表插入到文档说明中
<param>         标记方法的参数(编译器要验证其语法)
<paramref>      表示一个单词是方法的参数(编译器要验证其语法)
<permission>    说明对成员的访问(编译器要验证其语法)
<remarks>       给成员添加描述
<returns>       说明方法的返回值
<see>           提供对另一个参数的交叉引用(编译器要验证其语法)
<seealso>       提供描述中的“参见”部分(编译器要验证其语法)
<summary>       提供类型或成员的简短小结
<value>         描述属性
```
1>给类及其 Add 方法添加一个<summary>元素，也给 Add 方法添加一个<returns>元素和两个<param>元素：

```
// Math.cs
namespace Wrox.ProCSharp.Basics
{
///<summary>
/// Wrox.ProCSharp.Basics.Math class.
/// Provides a method to add two integers.
///</summary>
public class Math
{
///<summary>
/// The Add method allows us to add two integers
///</summary>
///<returns>Result of the addition (int)</returns>
///<param name="x">First number to add</param>
///<param name="y">Second number to add</param>
public int Add(int x, int y)
{
return x + y;
}
}
}
```
C#编译器可以把 XML 元素从特定的注释中提取出来，并使用它们生成一个 XML 文件。要让编译器为程序集生成 XML 文档说明，需在编译时指定/doc 选项，后跟要创建的文件名：
csc /t:library /doc:Math.xml Math.cs

代码会生成一个 XML 文件 Math.xml:

```
<?xml version="1.0"?>
<doc>
<assembly>
<name>Math</name>
</assembly>
<members>
<member name="T:Wrox.ProCSharp.Basics.Math">
<summary>
Wrox.ProCSharp.Basics.Math class.
Provides a method to add two integers.
</summary>
</member>
<member name=
"M:Wrox.ProCSharp.Basics.Math.Add(System.Int32,System.Int32)">
<summary>
The Add method allows us to add two integers.
</summary>
<returns>Result of the addition (int)</returns>
<param name="x">First number to add</param>
<param name="y">Second number to add</param>
</member>
</members>
</doc>
```

注意：编译器为我们做了一些工作——它创建了一个<assembly>元素，并为该文件中的每个类型或类型成员添加一个<member>元素。每个<member>元素都有一个 name 特性，其中包৿成员的全名，前面有一个字母表示其类型： "T:"表示这是一个类型， "F:" 表示这是一个字段， "M:" 表示这是一个成员。

(20)C#预处理器指令

1)预处理器指令的开头都有符号#。
1>#define 的用法如下所示：

```
#define DEBUG,
```
类似于声明一个变量，但这个变量并没有真正的值，只是存在而已。
2>#undef 正好相反—— 删除符号的定义：

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

注意：预处理器指令不用分号结束，一般一行上只有一个命令。这是因为对于预处理器指令， C#不再要求命令用分号结束。如果它遇到一个预处
理器指令，就会假定下一个命令在下一行上。


(21)C# 编程规则
1）标识符规则
1> 它们必须以一个字母或下划线开头，但可以包৿数字字符；
2> 不能把 C#关键字用作标识符。

```
            表 2-11
abstract   do        In         protected       true
as         double    Int        public          try
base       else      Interface  readonly        typeof
bool       enum      Internal   ref             uint
break      event     Is         return          ulong
byte       explicit  lock       sbyte           unchecked
case       extern    long       sealed          unsafe
catch      false     namespace  short           ushort
char       finally   new        sizeof          using
checked    fixed     null       stackalloc      virtual
class      float     object     static          volatile
const      for       operator   string          void
continue   foreach   out        struct          while
decimal    goto      override   switch
default    if        params     this
delegate   Implicit  private    throw
```