C#语言的基础知识

C#概述

C#是Miscrosoft在2000年7月推出.NET Framwork的第一版时提供的一种全新语言。

它吸收了C++、VisualBasic、Delphi、Java等有语言的优点、体现了当今最新的程序设计技术的功能和精华，C#继承了C语言的语法风格，同时又继承了C++的面向对象的特性。

C#语言主要用于开发可以在.net平台（一种构建下一代英特网的集成开发环境）上运行的应用程序，并作为。net平台的首选开发语言，甚至可以这么说，C#语言就是为了.Net平台而产生的语言。C#的语言体系是构建在.net框架基础上的，他是从C、C++/jiava派生而来的一种简单，现代、面向对象和类型安全的编程语言、并且能够与、net框架完美结合。

C#语言及特点

7. 完善的错误、异常处理机制。

第一个C#程序

Main是一个特殊函数，编译器把它作为程序的起始点

标识符

@字符只能放在标示符的首位

命名规范

Camel命名法

首个单词的首字母小写，其余单词的首字母大写(enemyHp)

Pascal命名规范

变量使用Camel命名，方法和类使用Pascal命名规范

关键字

用来定义C#语言的字符串记号

所有C#关键字全部由小写字母组成

Main方法

Main方法最简单的形式：

static void Main(){
}

什么是语句？

语句是描述一个类型或告诉程序去执行某个动作的一条源代码指令，语句以分号结束。

int var1 = 5;
System.Console.WriteLine("The value of var1 is {0}",var1);

什么是块？

块是一个由大括号包围起来的0条或多条语句序列，它在语法上相当于一条语句。

{
int var1 = 5;
System.Console.WriteLine("The value of var1 is {0}",var1);
}

块的内容：

2，语句可以以分号结束，但块后面不跟分号

从程序中输出文本

控制台窗口是一个简单的命令提示窗口，允许程序显示文本并从键盘接受输入。BCL提供一个Console的类（在System命名空间下）,该类包含了输入和输出到控制台窗口的方法。

Write

Write是Console类的成员，它把一个文本字符串发送到程序的控制台窗口。最简单的使用，Write把文本的字符串字面量发送到窗口，字符串必须使用双引号括起来。

实例：

Console.Write("This is a trivial text.");

WriteLine

WriteLine是Console的另外一个成员，它和Write实现相同的功能，但会在每个输出字符串的结尾添加一个换行符。

System.Console.WriteLine("Hello world1.");
System.Console.WriteLine("Hello world2.");
System.Console.WriteLine("Hello world3.");

格式化字符串

当利用Write和WriteLine方法输出的时候，可以对字符串进行格式化输出，什么是格式化输出呢？

Console.WriteLine("两个数相加{0}+{1}={2}",3,34,34);

多重标记和值

Console.WriteLine("Three integers are {1},{0} and {1}",3,5);

变量

为什么使用变量?

计算机程序的运行其实就是对数据的操作，数据是什么？比如数字，文字，图片这些在计算机中都是数据，那么数据怎么在计算机中存储呢？

答案：通过变量

你可以把计算机内存中的变量，当成一个盒子，盒子里面存储着东西，可以放入或者取出

变量的声明

声明变量需要指定类型和变量名

<type> <name>;

type表示使用什么类型的盒子，来存储数据

name表示存储这个盒子的名字

实例:(每一个声明都是一条语句，语句以；结束)

int age;
  int hp;
  string name;

简单类型-整数

简单类型-小数

简单类型-非数值类型

字面值

字面值列表

char和string

类型介绍

string是一个char的数组，数组以后介绍，现在先把string认为字符的集合

转义字符列表

转义字符是有特殊功能的字符

字符的Unicode值的作用

Unicode是一个16进制的数字，表示这个字符在内存中以哪个数字存储，也可以使用Unicode来代表一个转义字符 (\u加上十六进制值)

"I\u0027s siki!"

使用@不识别转义字符

如果我们不想去识别字符串中的转义字符，可以在字符串前面加一个@符号（除了双引号其他转义字符都不在识别）

举例："I'm a good man. \n You are bad girl!",使用两个引号表示一个引号

@字符的两个作用示例：

1，默认一个字符串的定义是放在一行的，如果

想要占用多行

使用@"c:\xxx\xx\xxx.doc"更能读懂

变量的声明和赋值

变量的声明

int age ;

变量的赋值

age = 25;

变量的声明和赋值可以放在一个语句中

int age = 25;

多变量声明和赋值

我们可以使用一条语句声明多个类型一样的变量

string name1,name2;

在多变量声明中，可以在变量后面跟上=，对其中的一个变量或者部分或者全部变量进行初始化

注意事项

变量在使用之前必须初始化

怎么判断变量有没有使用，当你从变量的盒子里面取东西的时候，就是要使用这个变量的时候，初始化就是先往这个盒子里面放入东西，才能去取

第一次给变量赋值，就叫做初始化

表达式

前面说了如何创建变量，下面就是处理他们了，C#包含了许多进行这类处理的运算符。

把变量和字面值和运算符组合起来就是表达式

运算符的分类

三元运算符 处理三个操作数

数学运算符

关于数学运算符的结果类型

当两边的操作数类型一致的时候，返回的结果跟操作数的类型一样

当两边的操作数类型不一致的时候，返回的结果跟类型大的操作数保持一致，这样做编译器是为了保证结果可以存的下，因为如果其中有一个类型大的操作数，很可能结果也是一个比较大的数值这样小类型是存不下的。

接受用户输入的字符串，整数和小数

内容呢

通过Console.ReadLine()方法，这个方法可以从键盘上读取一行的字符串输入，返回的是一个字符串

赋值运算符

用来向变量盒子存东西的运算符

运算符的优先级

var1 = (var2+var3)*var4;

括号可以用来重写优先级 括号内的优先级最高

访问修饰符

访问修饰符：

5.protected internal：内部保护访问 只能是本项目内部或子类访问 其他类不能访问

访问级别约束：

2.方法的访问修饰符要和方法参数的访问修饰符 保持一致

常量

常量就是其值固定不变的量，而且常量的值在编译时就已经确定了。常量的类型只能为下列类型之一：sbyte、byte、short、ushort、int、uint、long、ulong、char、float、double、decimal、bool、string等。

常量就相当于每个公民的身份证号，一旦设置就不允许修改。

声明一个正确的常量，同时再声明一个错误的常量，以便读者对比参考，代码如下。

const int MyInt; //错误：定义常量时没有初始化

常量的成员

Readonly：声明的时候可以不赋值，但是一但赋值就不能更改

流程控制语句

三种结构：顺序结构，选择结构、循环结构

什么是流程控制

为什么使用流程控制

我们至今写的代码都是一行接着一行，自上而下进行。但是有的时候我想根据程序中当时的环境执行不同的代码，或者有的时候需要重复执行某段代码。这两种方法就是需要用到流程控制中的分支和循环。

分支：有条件的执行代码

循环：重复执行相同的代码

选择语句（if-else）

后面的内嵌语句。

if (布尔表达式 )

真值运算; //表达式为真时运算

else

假值运算;

2、if语句可以嵌套使用

选择语句（switch-case）

一个 switch 语句允许测试一个变量等于多个值时的情况。每个值称为一个 case，且被测试的变量会对每个 switch case 进行检查。

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

1.switch 语句中的 expression 必须是一个整型或枚举类型，或者是一个 class 类型，其中 class 有一个单一的转换函数将其转换为整型或枚举类型。

2.在一个 switch 中可以有任意数量的 case 语句。每个 case 后跟一个要比较的值和一个冒号。

case 的 constant-expression 必须与 switch 中的变量具有相同的数据类型，且必须是一个常量。

3.当被测试的变量等于 case 中的常量时，case 后跟的语句将被执行，直到遇到 break 语句为止。

当遇到 break 语句时，switch 终止，控制流将跳转到 switch 语句后的下一行。

4.不是每一个 case 都需要包含 break。如果 case 语句为空，则可以不包含 break，控制流将会 继续 后续的 case，直到遇到 break 为止。

5.C# 不允许从一个 case 部分继续执行到下一个 case 部分。如果 case 语句中有已经执行，则必须包含 break 或其他跳转语句。

6.一个 switch 语句可以有一个可选的 default 语句，在 switch 的结尾。default 语句用于在上面所有 case 都不为 true 时执行的一个任务。default 也需要包含 break 语句，这是一个良好的习惯。

7.C# 不支持从一个 case 标签显式贯穿到另一个 case 标签。如果要使 C# 支持从一个 case 标签显式贯穿到另一个 case 标签，可以使用 goto 一个 switch-case 或 goto default。

for循环

一个 for 循环是一个允许您编写一个执行特定次数的循环的重复控制结构。

语法

}

接下来，会判断 condition。如果为真，则执行循环主体。如果为假，则不执行循环主体，且控制流会跳转到紧接着 for 循环的下一条语句。

条件再次被判断。如果为真，则执行循环，这个过程会不断重复（循环主体，然后增加步值，再然后重新判断条件）。在条件变为假时，for 循环终止。

foreach循环

使用foreach可以迭代数组或者一个集合对象。

枚举（enum）

枚举类型的定义：

enum <typeName>{
<value1>,
<value2>,
<value3>,
.....
<valueN>
}

枚举类型声明：<type> <varName>;

枚举类型的赋值：<varName>=<typeName> .<value>;

例如，我们声明一个代表星期的枚举类型的变量：

enum WeekDay
{ Sunday，Monday，Tuesday，Wednesday，Thursday，Friday，Saturday }
WeekDay day;

它的星期元素

跳转语句

return语句：

如果方法为void 类型，则可以省略 return 语句。

break语句：

止语句后面的语句。

continue语句：

将控制权传递给它所在的封闭迭代语句的下一次迭代

递归方法调用

一个方法可以自我调用。这就是所谓的 递归。下面的实例使用递归函数计算一个数的阶乘：using System;

namespace CalculatorApplication
{
    class NumberManipulator
    {
        public int factorial(int num)
        {
            /* 局部变量定义 */
            int result;
            if (num == 1)
            {
                return 1;
            }
            else
            {
                result = factorial(num - 1) * num;
                return result;
            }
        }
   
        static void Main(string[] args)
        {
            NumberManipulator n = new NumberManipulator();
            //调用 factorial 方法
            Console.WriteLine("6 的阶乘是： {0}", n.factorial(6));
            Console.WriteLine("7 的阶乘是： {0}", n.factorial(7));
            Console.WriteLine("8 的阶乘是： {0}", n.factorial(8));
            Console.ReadLine();
        }
    }
}

数组（Array）

数组是一个存储相同类型元素的固定大小的顺序集合。数组是用来存储数据的集合，通常认为数组是一个同一类型变量的集合。

声明数组变量并不是声明 number0、number1、...、number99 一个个单独的变量，而是声明一个就像 numbers 这样的变量，然后使用 numbers[0]、numbers[1]、...、numbers[99] 来表示一个个单独的变量。数组中某个指定的元素是通过索引来访问的。

所有的数组都是由连续的内存位置组成的。最低的地址对应第一个元素，最高的地址对应最后一个元素

声明数组

语法：

其中，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。

访问数组元素

using System;
namespace ArrayApplication
{
   class MyArray
   {
      static void Main(string[] args)
      {
         int []  n = new int[10]; /* n 是一个带有 10 个整数的数组 */
         int i,j;
         /* 初始化数组 n 中的元素 */        
         for ( i = 0; i < 10; i++ )
         {
            n[ i ] = i + 100;
         }
         /* 输出每个数组元素的值 */
         for (j = 0; j < 10; j++ )
         {
            Console.WriteLine("Element[{0}] = {1}", j, n[j]);
         }
         Console.ReadKey();
      }
   }
}

一维数组的声明

一维数组即数组的维数为1，其声明语法如下：

þ arrayName：数组名称。

对数组中元素进行初始化使用new运算符

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Test01
{
   class Program
    {
       static void Main(string[] args)
        {
           int[] arr = { 1, 2, 3, 4, 5 };                //定义一个一维数组，并为其赋值
            foreach (int n in arr)                    //使用foreach语句循环遍历一维数组中的元素
                Console.WriteLine("{0}", n + " ");
            Console.WriteLine();
        }
    }
}

二维数组的声明

二维数组的声明语法如下。

其中：type表示数组存储数据的数据类型；arrayName表示数组名称。

int[,]arr=newint[2,2];

int[,]arr=newint[2,2]{{1,2},{3,4}};

int[,]arr=newint[,]{{1,2},{3,4}};

值类型

值类型直接包含数据。比如 int、char、float，它们分别存储数字、字符、浮点数。当您声明一个 int 类型时，系统分配内存来存储值。

引用类型

内置的 引用类型有：object、dynamic 和 string。

int [] l={1,2,3};
int [] l2=1;
l[0]=9;
Console.WriteLine("l2[0]"+l2[0]);

数据类型的转换

int age2 = (int)age1;

C#面向对象三大特性：

封装

什么是封装

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

封装的优点

1. 隔离性，安全性。被封装后的对象（这里的对象是泛指代码的编程单元，一般指：程序集，命名空间，类，方法，属性，变量等）其外部对象是无法直接访问对象的内部实现细节，内部实现细节的的改动不会影响到外部对象的访问原则。

2. 可读性。被封装的对象的名称恰当的话，可以不看具体实现的情况下，了解该对象的作用

3. 良好的封装能够减少耦合（比如实现界面和逻辑分离）

4. 类具有清晰的对外接口，使用者只需调用，无需关心内部

5. 因为封装的类功能相对独立，因此能更好的实现代码复用

访问修饰符包含的类型

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

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

public：所有对象都可以访问；

private：对象本身在对象内部可以访问；

protected：只有该类对象及其子类对象可以访问

internal：同一个程序集的对象可以访问；

protected internal：访问限于当前程序集或派生自

默认访问修饰符

在命名空间内部或编译单元顶部的所有类型（class、struct、abstract class、interface、delegate、enum），默认是internal，可以人为改为public

类中所有的成员，默认均为private

抽象类的所有成员，默认均为private类型，但抽象方法不能用private修饰

接口的所有成员，默认均为public类型，而且不能手动添加访问修饰符

结构的所有成员，默认均为private类型，而且只能是public、internal、private这三种类型

命名空间，枚举类型成员默认public，也不可能是其他访问修饰符

委托，默认internal

继承

什么是继承

定义：继承是面向对象编程语言中的一个重要特性，当一个类A能够获取另一个类B中所有非私有的数据和操作的定义作为自己的部分或全部成分时，就称这两个类之间具有继承关系。被继承的类B称为父类或基类，继承了父类的类A称为子类或派生类。

继承的优点

5. 通过子类重写父类的功能可支持代码扩展

继承的缺点

2. 在继承结构中，很多数据成员仍然没有被使用，分配给他们的内存没有被利用；因此，如果你没有正确地使用继承，将影响程序性能

继承的特点

4. 子类可以以自己的方式实现父类的功能（即方法重写）

继承的特性

单根性：一个子类只能有一个父类

传递性：由A:B B:C=>A:C

实现继承

如果要声明派生自另一个类的一个类，就可以使用下面的语法 :

class MyDerivedClass: MyBaseClass
{
  // functions and data members here
}

如果类(或结构)也派生自接口，则用逗号分隔列表中的基类和接口 :

public class MyDerivedClass: MyBaseC1ass, IInterface1, IInterface2
{
    // etc.
}

对于结构，语法如下 :

public struct MyDerivedstruct: IInterface1, IInterface2
{
    // etc.
}

多重继承

C# 不支持多重继承。但是，可以使用接口来实现多重继承。

要点：

子类不仅继承了父类的公有成员，同时继承了父类的私有成员，只是父类的私有成员在子类中不可被访问；

构造方法不能继承

多态

什么是多态

上述例子就是一个典型的多态，就是父类的一些成员，子类继承后去重写从而实现不同的功能。

定义：

多态的优缺点

好处：

简化代码。如果函数/方法参数中使用的是父类的类型，可以传入父类、子类的对象

局限性：

注意：子类中如果重写了父类的方法(多态)，那么父类中的这个方法将不会再调用。

多态的分类

多态性分为两种，一种是编译时的多态性，一种是运行时的多态性。

编译时的多态性（重载）：

编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。

运行时的多态性（重写）：

运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中运行时的多态性是通过覆写虚成员实现。

多态的实现

C.重载只是针对一个类内部的几个参数不同，名称相同的方法。

实例说明

/// <summary>
/// 狗(多态：重载事例)
/// </summary>
class Dog
{
    /// <summary>
    /// 叫
    /// </summary>
    public void Shout()
    {
        Console.WriteLine("汪!");
    }
    /// <summary>
    /// 叫(重载方法)
    /// </summary>
    public void Shout(int count)
    {
        int i = 0;
        string shout = "";
        do
        {
            shout += "汪！";
            i++;
        } while (i <= count);
        Console.WriteLine(shout);
    }
}