C#简述（二）

详情请参考：http://www.runoob.com/csharp/csharp-operators.html

1.C# 运算符

• 算术运算符
• 关系运算符
• 逻辑运算符
• 位运算符
• 赋值运算符
• 其他运算符

&，|，^ 除了用于位运算，还可以用于逻辑运算，分别对应与，或，异或。

C# 中的运算符优先级

2.C# 判断

switch 语句必须遵循下面的规则：

• switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型。
• 在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。
• case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量。
• 当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。
• 当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。
• 不是每一个 case 都需要包含 break。如果 case 语句为空，则可以不包含 break，控制流将会 继续 后续的 case，直到遇到 break 为止。
• C# 不允许从一个开关部分继续执行到下一个开关部分。如果 case 语句中有处理语句，则必须包含 break 或其他跳转语句。
• 一个 switch 语句可以有一个可选的 default case，出现在 switch 的结尾。default case 可用于在上面所有 case 都不为真时执行一个任务。default case 中的 break 语句不是必需的。
• C# 不支持从一个 case 标签显式贯穿到另一个 case 标签。如果要使 C# 支持从一个 case 标签显式贯穿到另一个 case 标签，可以使用 goto 一个 switch-case 或 goto default。

? : 运算符

条件运算符 ? :，可以用来替代 if...else 语句

3.C# 循环

 　　　　　　 int[] ints = { ,,,,};
            foreach(int myInt in ints)
            {
                System.Console.WriteLine(myInt);
            }
            Console.WriteLine();

循环控制语句

无限循环

如果条件永远不为假，则循环将变成无限循环。for 循环在传统意义上可用于实现无限循环。由于构成循环的三个表达式中任何一个都不是必需的，可以将某些条件表达式留空来构成一个无限循环。

 for (; ; )
 {
      Console.WriteLine("Hey! I am Trapped");
 }
当条件表达式不存在时，它被假设为真。您也可以设置一个初始值和增量表达式，但是一般情况下，程序员偏向于使用 for(;;) 结构来表示一个无限循环。

4.C# 封装

封装 被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。

抽象和封装是面向对象程序设计的相关特性。抽象允许相关信息可视化，封装则使开发者实现所需级别的抽象。

C# 封装根据具体的需要，设置使用者的访问权限，并通过 访问修饰符 来实现。

一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：

• public：所有对象都可以访问；
• private：对象本身在对象内部可以访问；
• protected：只有该类对象及其子类对象可以访问；
• internal：同一个程序集的对象可以访问；
• protected internal：访问限于当前程序集或派生自包含类的类型。

http://www.runoob.com/csharp/csharp-encapsulation.html

5.C# 方法

一个方法是把一些相关的语句组织在一起，用来执行一个任务的语句块。每一个 C# 程序至少有一个带有 Main 方法的类。

C# 中定义方法

在 C# 中，定义方法的语法如下：

<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
   Method Body
}

public int FindMax(int num1, int num2)
   {
      /* 局部变量声明 */
      int result;

      if (num1 > num2)
         result = num1;
      else
         result = num2;

      return result;
   }

C# 中调用方法

 　　　　　　 NumberManipulator n = new NumberManipulator();
            //调用 FindMax 方法
            ret = n.FindMax(a, b);
            Console.WriteLine("最大值是： {0}", ret );

递归方法调用

一个方法可以自我调用。这就是所谓的 递归。

参数传递

在 C# 中，有三种向方法传递参数的方式：

按值传递参数

即使在函数内改变了值，值也没有发生任何的变化。

public void swap(int x, int y)
      {
         int temp;

         temp = x; /* 保存 x 的值 */
         x = y;    /* 把 y 赋值给 x */
         y = temp; /* 把 temp 赋值给 y */
      }

按引用传递参数

引用参数是一个对变量的内存位置的引用。当按引用传递参数时，与值参数不同的是，它不会为这些参数创建一个新的存储位置。引用参数表示与提供给方法的实际参数具有相同的内存位置。

在 C# 中，使用 ref 关键字声明引用参数。

 public void swap1(int a, int b)
        {
            int x = a;
            a = b;
            b = x;
        }
        public void swap2(ref int a, ref int b)
        {
            int x = a;
            a = b;
            b = x;
        }

            int x=;
            int y=;
            animal.swap1(x, y);
            Console.WriteLine("before:"+x);
            Console.WriteLine("before:" + y);
            animal.swap2(ref x,ref y);
            Console.WriteLine("after:" + x);
            Console.WriteLine("after:" + y);

按输出传递参数

return 语句可用于只从函数中返回一个值。但是，可以使用 输出参数 来从函数中返回两个值。输出参数会把方法输出的数据赋给自己，其他方面与引用参数相似。

  public void getValues(out int x, out int y )
      {
          Console.WriteLine("请输入第一个值： ");
          x = Convert.ToInt32(Console.ReadLine());
          Console.WriteLine("请输入第二个值： ");
          y = Convert.ToInt32(Console.ReadLine());
      }

      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部变量定义 */
         int a , b;

         /* 调用函数来获取值 */
         n.getValues(out a, out b);

         Console.WriteLine("在方法调用之后，a 的值： {0}", a);
         Console.WriteLine("在方法调用之后，b 的值： {0}", b);
         Console.ReadLine();
      }

一个用关键字 ref 标示，一个用 out 标示。

牵扯到数据是引用类型还是值类型。

一般用这两个关键字你是想调用一个函数将某个值类型的数据通过一个函数后进行更改。传 out 定义的参数进去的时候这个参数在函数内部必须初始化。否则是不能进行编译的。ref 和 out 都是传递数据的地址，正因为传了地址，才能对源数据进行修改。

一般情况下不加 ref 或者 out 的时候，传值类型的数据进去实际上传进去的是源数据的一个副本，也就是在内存中新开辟了一块空间，这里面存的值是与源数据相等的，这也就是为什么在传值类型数据的时候你如果不用 return 是无法修改原值的原因。但是你如果用了 ref,或者 out，这一切问题都解决了，因为他们传的是地址。

out 比起 ref 来说，还有一个用法就是可以作为多返回值来用，都知道函数只能有一个返回值，C#里，如果想让一个函数有多个返回值，那么OUT能很容易解决。

6.C# 可空类型（Nullable）

? : 单问号用于对 int,double,bool 等无法直接赋值为 null 的数据类型进行 null 的赋值，意思是这个数据类型是 NullAble 类型的。

int? i =
等同于
Nullable<int> i = new Nullable<int>();

int i; //默认值0
int? ii; //默认值null

?? : 双问号 可用于判断一个变量在为 null 时返回一个指定的值。

C# 可空类型（Nullable）

C# 提供了一个特殊的数据类型，nullable 类型（可空类型），可空类型可以表示其基础值类型正常范围内的值，再加上一个 null 值。
例如，Nullable< Int32 >，读作"可空的 Int32"，可以被赋值为 -2,147,483,648 到 2,147,483,647 之间的任意值，也可以被赋值为 null 值。类似的，Nullable< bool > 变量可以被赋值为 true 或 false 或 null。
在处理数据库和其他包含可能未赋值的元素的数据类型时，将 null 赋值给数值类型或布尔型的功能特别有用。例如，数据库中的布尔型字段可以存储值 true 或 false，或者，该字段也可以未定义。

声明一个 nullable 类型（可空类型）的语法如下：

< data_type> ? <variable_name> = null;

 　　　　 int? num1 = null;
         int? num2 = ;
         double? num3 = new double?();
         double? num4 = 3.14157;

         bool? boolval = new bool?();

         // 显示值

         Console.WriteLine("显示可空类型的值： {0}, {1}, {2}, {3}",
                            num1, num2, num3, num4);
         Console.WriteLine("一个可空的布尔值： {0}", boolval);
         Console.ReadLine();

Null 合并运算符（ ?? ）

 Null 合并运算符用于定义可空类型和引用类型的默认值。Null 合并运算符为类型转换定义了一个预设值，以防可空类型的值为 Null。Null 合并运算符把操作数类型隐式转换为另一个可空（或不可空）的值类型的操作数的类型。

如果第一个操作数的值为 null，则运算符返回第二个操作数的值，否则返回第一个操作数的值。下面的实例演示了这点：

         double? num1 = null;
         double? num2 = 3.14157;
         double num3;
         num3 = num1 ?? 5.34;      // num1 如果为空值则返回 5.34
         Console.WriteLine("num3 的值： {0}", num3);
         num3 = num2 ?? 5.34;
         Console.WriteLine("num3 的值： {0}", num3)     

7.C# 数组（Array）

声明数组：

datatype[] arrayName;
例如：

double[] balance;

初始化数组

声明一个数组不会在内存中初始化数组。当初始化数组变量时，可以赋值给数组。

数组是一个引用类型，所以您需要使用 new 关键字来创建数组的实例。

double[] balance = new double[10];

赋值给数组

可以通过使用索引号赋值给一个单独的数组元素

double[] balance = new double[10];
balance[0] = 4500.0;

也可以在声明数组的同时给数组赋值，比如：

double[] balance = { 2340.0, 4523.69, 3421.0};

也可以创建并初始化一个数组，比如：

int [] marks = new int[5]  { 99,  98, 92, 97, 95};

在上述情况下，也可以省略数组的大小，比如：

int [] marks = new int[]  { 99,  98, 92, 97, 95};

也可以赋值一个数组变量到另一个目标数组变量中。在这种情况下，目标和源会指向相同的内存位置：

int [] marks = new int[]  { 99,  98, 92, 97, 95};
int[] score = marks;

当创建一个数组时，C# 编译器会根据数组类型隐式初始化每个数组元素为一个默认值。例如，int 数组的所有元素都会被初始化为 0。

访问数组元素

元素是通过带索引的数组名称来访问的。这是通过把元素的索引放置在数组名称后的方括号中来实现的。例如：

double salary = balance[9];

C# 数组细节

——C# 多维数组

int [,] a = new int [,] {
 {, , , } ,   /*  初始化索引号为 0 的行 */
 {, , , } ,   /*  初始化索引号为 1 的行 */
 {, , , }   /*  初始化索引号为 2 的行 */
};

int val = a[2,3];

———C# 交错数组

交错数组是数组的数组。可以声明一个带有 int 值的交错数组 scores，如下所示：

int [][] scores;

int[][] scores = new int[5][];
for (int i = 0; i < scores.Length; i++)
{
   scores[i] = new int[4];
}
int[][] scores = new int[2][]{new int[]{92,93,94},new int[]{85,66,87,88}};

其中，scores 是一个由两个整型数组组成的数组 -- scores[0] 是一个带有 3 个整数的数组，scores[1] 是一个带有 4 个整数的数组。

 ————C# 传递数组给函数
可以通过指定不带索引的数组名称来给函数传递一个指向数组的指针。
————C# 参数数组
当声明一个方法时，不能确定要传递给函数作为参数的参数数目。C# 参数数组解决了这个问题，参数数组通常用于传递未知数量的参数给函数。

params 关键字

在使用数组作为形参时，C# 提供了 params 关键字，使调用数组为形参的方法时，既可以传递数组实参，也可以传递一组数组元素。params 的使用格式为：

public 返回类型 方法名称( params 类型名称[] 数组名称 )

   class ParamArray
   {
      public int AddElements(params int[] arr)
      {
         int sum = ;
         foreach (int i in arr)
         {
            sum += i;
         }
         return sum;
      }
   }

   class TestClass
   {
      static void Main(string[] args)
      {
         ParamArray app = new ParamArray();
         int sum = app.AddElements(, , , , );
         Console.WriteLine("总和是： {0}", sum);
         Console.ReadKey();
      }
   }

——C# Array 类

Array 类是 C# 中所有数组的基类，它是在 System 命名空间中定义。Array 类提供了各种用于数组的属性和方法。
http://www.runoob.com/csharp/csharp-array-class.html