C#语言基础部分

C#语言基础部分

参考资料：

• b站视频教程
• 菜鸟教程
• 仅摘取和记录对自身而言有用的复习内容

写代码：代码.cs—生成—exe—执行

---

• Console.Write(); 输出不换行

• Console.WriteLine(); 输出并换行

• Console.ReadLine(); 读取键盘输入的所有字符，返回字符串。按下回车键退出

• Console.Read(); 读取键盘输入的第一个字符，返回其对应的ASCII值。按下回车键退出

• Console.ReadKey(); 等待用户按下任意键并执行退出，(此函数的作用是为了在控制台窗口停留一下，直到用户敲击键盘为止。不然运行时，“Hello World!” 这句话会在控制台窗口一闪而过，没法查看。)

---

1.C#程序结构

---

using System;
//程序的第一行 using System; - using 关键字用于在程序中包含 System 命名空间。 一个程序一般有多个 using 语句。
namespace HelloWorldApplication
{
//下一行是 namespace 声明。一个 namespace 里包含了一系列的类。HelloWorldApplication 命名空间包含了类 HelloWorld。
   class HelloWorld
//下一行是 class 声明。类 HelloWorld 包含了程序使用的数据和方法声明。类一般包含多个方法。方法定义了类的行为。在这里，HelloWorld 类只有一个 Main 方法。
   {
      static void Main(string[] args)
      {
         /* 我的第一个 C# 程序*/
         Console.WriteLine("Hello World");
//Main 方法通过语句 Console.WriteLine("Hello World"); 指定了它的行为。
WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法。该语句会在屏幕上显示消息 "Hello World"。
         Console.ReadKey();
//最后一行 Console.ReadKey(); 是针对 VS.NET 用户的。这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。
      }
   }
}

• 命名空间直接理解就是类的住址

• 它的作用是对类进行逻辑上的划分，避免重名

---

2.C#基础语法

---

在 C# 中，变量分为以下几种类型：

• 值类型（Value types）
• 引用类型（Reference types）
• 指针类型（Pointer types）

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

对象（Object）类型

• Object 是 System.Object 类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。

• 但是，在分配值之前，需要先进行类型转换。

• 当一个值类型转换为对象类型时，则被称为 装箱；另一方面，当一个对象类型转换为值类型时，则被称为 拆箱。

int val = 8;
object obj = val;//整型数据转换为了对象类型（装箱）

int val = 8;
object obj = val;//先装箱
int nval = （int）obj;//再拆箱

动态（Dynamic）类型

您可以存储任何类型的值在动态数据类型变量中。这些变量的类型检查是在运行时发生的。

声明动态类型的语法：

dynamic d = 20;

字符串（String）类型

• 允许您给变量分配任何字符串值。

• 字符串（String）类型是 System.String 类的别名。

• 它是从对象（Object）类型派生的。

• 字符串（String）类型的值可以通过两种形式进行分配：引号和 @引号。

string str = @"C:\Windows";

string str = "C:\\Windows";

指针类型

形如c/c++

---

3.类型转换

---

  *// 强制转换 double 为 int*
  i = (**int**)d;

such as:

ToString
把类型转换为字符串类型。

  Console.WriteLine(i.ToString());

具体可参考菜鸟教程：C# 类型转换 | 菜鸟教程 (runoob.com)

Parse转换：String转换为其它数据类型

待转数据必须像数据类型

string strNumber="18.0";
int num02 = int.Parse(strNumber);//18

任意类型转化为string

int number=18;
string str=number.ToString();

隐式转换和显式转换

小到大可隐式转换

大到小应该遵循规则：

int a=100;
byte b=(byte)a;

int到short不能隐式转换

---

4.C#常量

---

形如c++/c

注意1：命名规则上以小写字母开头，如果包含多个单词，除第一个单词外其它单词首字母大写，增加前缀类型便于理解

注意2：静态常量和动态常量

1.静态常量（编译时常量）const

在编译时就确定了值，必须在声明时就进行初始化且之后不能进行更改，可在类和方法中定义。定义方法如下：

const double a=3.14；// 正确声明常量的方法
const int b;         // 错误，没有初始化

2.动态常量（运行时常量）readonly

在运行时确定值，只能在声明时或构造函数中初始化，只能在类中定义。定义方法如下：

class Program
{
    readonly int a=1;  // 声明时初始化
    readonly int b;    // 构造函数中初始化
    Program()
    {
        b=2;
    }
    static void Main()
    {
    }
}

decimal可避免double和float的误差

decimal num01 = 3.0m;

一个字符串和一个字符之间连接用“+”号

---

5.C#运算符，判断，循环

---

皆形如C/C++

• C# 运算符 | 菜鸟教程 (runoob.com)

• C# 判断 | 菜鸟教程 (runoob.com)

• C# 循环 | 菜鸟教程 (runoob.com)

---

6.C#封装

---

封装

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

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

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

---

C# 方法 | 菜鸟教程 (runoob.com)

---

---

7.C#访问

---

• such as

string.Format("枪的名称是{0}，容量为{1}"，gun，5)

{0}代表后面第一个，{1}代表后面第二个

• 标准数字字符串格式化

Console.WriteLine("金额:{0:c}",10);//货币10
Console.WriteLine("{0:d2}",5);//05,不足两位用0填充
Console.WriteLine("{0:f1}",1.26);//1.3，精度四舍五入
Console.WriteLine("{0:p0}",0.1);//10%，以百分数显示
Console.WriteLine("我爱\"unity\"");转义字符
char c1='\'';//'
char c2='\0';//空字符
Console.WriteLine("你好，\r\n我是隔壁老王");
//代表回车换行
//\t代表空格 

---

8.C#可空类型

---

• 双问号

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

C# 中两个问号的作用是判断??左边的对象是否为 null，如果不为 null 则使用 ?? 左边的对象，如果为 null 则使用 ?? 右边的对象。

• 单问号

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

int? i = 3;
//等同于
Nullable<int> i = new Nullable<int>(3);
/*---------*/
int i; //默认值0
int? ii; //默认值null
 //?? 双问号用于判断一个变量在为 null 的时候返回一个指定的值。   

具体网址：C# 可空类型 | 菜鸟教程 (runoob.com)

---

9.C#数组

---

数组在c#中和c/c++中开始有区别了

datatype[] arrayName;

其中，

• 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;

访问数组

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();
      }
   }
}

输出结果：

Element[0] = 100
Element[1] = 101
Element[2] = 102
Element[3] = 103
Element[4] = 104
Element[5] = 105
Element[6] = 106
Element[7] = 107
Element[8] = 108
Element[9] = 109

访问数组还可以使用foreach，个人感觉很不错

配合Array有更方便的访问用法

 foreach(int j in n )
 {
  int i = j-100;
  Console.WriteLine("Element[{0}] = {1}", i, j);
 }
 Console.ReadKey();

关于数组及其Array类的使用

C# 数组（Array） | 菜鸟教程 (runoob.com)

常见操作：

• Array.Reverse(list);----逆转
• Array.Sort(list);----排序，仅支持一维数组

---

10.C#字符串String的具体用法

C# 字符串（String） | 菜鸟教程 (runoob.com)

例如，连接，比较。。。。

---

11.C#结构体

---

C# 字符串（String） | 菜鸟教程 (runoob.com)

---

12.C#枚举

enum <enum_name>
{ 
    enumeration list 
};

• enum_name 指定枚举的类型名称。
• enumeration list 是一个用逗号分隔的标识符列表。

例子：

using System;

public class EnumTest
{
    enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat };

    static void Main()
    {
        int x = (int)Day.Sun;
        int y = (int)Day.Fri;
        Console.WriteLine("Sun = {0}", x);
        Console.WriteLine("Fri = {0}", y);
    }
}

Sun = 0
Fri = 5

---

13.C#类

C# 类（Class） | 菜鸟教程 (runoob.com)

---

14.C#继承

---

继承是面向对象编程中的重要概念，当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。

• 语法

  <访问修饰符符> class <基类>
  {
   ...
  }
  class <派生类> : <基类>
  {
   ...
  }
  

• 继承要注意什么：子类可以有多个，父类只能有一个，不过虽然不能继承多个父类，但可以通过接口达到相同的目的。

• 典型继承的例子——from菜鸟教程

using System;
namespace RectangleApplication
{
   class Rectangle
   {
      // 成员变量
      protected double length;
      protected double width;
      public Rectangle(double l, double w)
      {
         length = l;
         width = w;
      }
      public double GetArea()
      {
         return length * width;
      }
      public void Display()
      {
         Console.WriteLine("长度： {0}", length);
         Console.WriteLine("宽度： {0}", width);
         Console.WriteLine("面积： {0}", GetArea());
      }
   }//end class Rectangle  
   class Tabletop : Rectangle
   {
      private double cost;
      public Tabletop(double l, double w) : base(l, w)
      { }
      public double GetCost()
      {
         double cost;
         cost = GetArea() * 70;
         return cost;
      }
      public void Display()
      {
         base.Display();
         Console.WriteLine("成本： {0}", GetCost());
      }
   }
   class ExecuteRectangle
   {
      static void Main(string[] args)
      {
         Tabletop t = new Tabletop(4.5, 7.5);
         t.Display();
         Console.ReadLine();
      }
   }
}

---

15.C# 多态性

---

• 静态多态性
  • 函数重载（与c/c++类似）
  • 运算符重载（C# 运算符重载 | 菜鸟教程 (runoob.com)）

---

16.C#接口**（interface）**

---

• 接口定义了属性，方法和事件，这些都是接口的成员。
• 接口只包含了成员的声明，接口提供了派生类应遵循的标准结构，接口使得实现接口的类或结构在形式上保持一致。
• 抽象类在某种程度上与接口相似，但是，它们大多只是用在当只有少数方法由基类声明由派生类实现时。
• 接口本身并不实现任何功能。
• 抽象类不能直接实例化，但允许派生出具体的，具有实际功能的类。

定义接口声明的实例：

interface IMyInterface
{
    void MethodToImplement();
}

• 接口的声明和类的声明类似，接口声明默认是punlic
• 通常接口命令以I字母开头，这个接口只有一个方法 MethodToImplement()，没有参数和返回值，当然我们可以按照需求设置参数和返回值。
• 继承接口后，我们需要实现接口的方法 MethodToImplement() , 方法名必须与接口定义的方法名一致。
• 接口的调用可以叠加，譬如一个接口承接了另一个接口，再由一个类所承接，那么这个类可以调用两个接口中的方法
• 具体实际例子可参见：C# 接口（Interface） | 菜鸟教程 (runoob.com)

---

17.C#命名空间（Namespace）

---

• 命名空间的设计目的是提供一种让一组名称与其他名称分隔开的方式。
• 在一个命名空间中声明的类的名称与另一个命名空间中声明的相同的类的名称不冲突。

namespace namespace_name
{
   // 代码声明
}

• using关键字可以使用命名空间内的函数方法，前面就不用加命名空间的名字了

譬如

using System
//那么调用system空间中的方法便可以不再写出system
    console.WriteLine("Hello world")

• 命名空间还可以嵌套
• 可以使用点（.）运算符访问嵌套的命名空间的成员

---

18.C#预处理器指令

---

• 预处理指令指导编译器在实际编译开始之前对信息进行预处理
• 所有的预处理器指令都是以#开始。且在一行上，只有空白字符可以出现在预处理指令前，预处理指令不是语句，所以它们不以;结束。
• C#编译器没有单独的预处理器
• 预处理器指令在条件编译时起作用，与C/C++不同的是，它们不是用来创建宏的，一个预处理器指令必须是该行上的唯一指令。

常见的预处理器：

#define pi
    //定义一个pi
#if(pi)
    //检测判断是否条件为真

更多详情请见：

C# 预处理器指令 | 菜鸟教程 (runoob.com)

---

C#中的字符转义，字符类，定位点，分组构造，限定符，反向引用构造，备份构造，替换，杂项构造，Regex类

C# 正则表达式 | 菜鸟教程 (runoob.com)

---

19.C#异常处理

---

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

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

语法：

try
{
    //异常语句
}
catch(ExceptionName e1)
{
    //错误处理代码
}
finally
{
    //要执行的语句
}    

C# 异常处理 | 菜鸟教程 (runoob.com)

---

20.C#文件的输入与输出

---

C# 文件的输入与输出 | 菜鸟教程 (runoob.com)

---

21.C#中的var关键字

• var 是3.5新出的一个定义变量的类型，其实也就是弱化类型的定义，VAR可代替任何类型

• 编译器会根据上下文来判断你到底是想用什么类型的，

• var可以理解为匿名类型，我们可以认为它是一个声明变量的占位符。

• 它主要用于在声明变量时，无法确定数据类型时使用。

使用var定义变量时有以下四个特点:

1. 必须在定义时初始化。也就是必须是var s = “abcd”形式，而不能是如下形式: var s; s = “abcd”;

2. 一但初始化完成，就不能再给变量赋与初始化值类型不同的值了。

3. var要求是局部变量。

4. 使用var定义变量和object不同，它在效率上和使用强类型方式定义变量完全一样。