1.1、数据类型

值类型

在这里插入图片描述
需得到一个类型或一个变量在特定平台上的准确尺寸，可以使用 sizeof 方法。表达式 sizeof(type) 产生以字节为单位存储对象或类型的存储尺寸。

using System;

namespace DataTypeApplication
{
   class Program
   {
      static void Main(string[] args)
      {
         Console.WriteLine("Size of int: {0}", sizeof(int));
         Console.ReadLine();
      }
   }
}

引用类型

引用类型不包含存储在变量中的实际数据，但它们包含对变量的引用。

换句话说，它们指的是一个内存位置。使用多个变量时，引用类型可以指向一个内存位置。如果内存位置的数据是由一个变量改变的，其他变量会自动反映这种值的变化。内置的引用类型有：object、dynamic 和 string。

对象类型

对象（Object）类型是 C# 通用类型系统（Common Type System - CTS）中所有数据类型的终极基类。Object 是 System.Object 类的别名。所以对象（Object）类型可以被分配任何其他类型（值类型、引用类型、预定义类型或用户自定义类型）的值。但是，在分配值之前，需要先进行类型转换。

# 当一个值类型转换为对象类型时，则被称为 装箱；另一方面，当一个对象类型转换为值类型时，则被称为 拆箱。
object obj;
obj = 100; // 这是装箱

int var;
object obj1 = 10;
var = (int)obj1; // 这是拆箱

指针类型

指针类型变量存储另一种类型的内存地址。C# 中的指针与 C 或 C++ 中的指针有相同的功能。
声明指针类型的语法：

char* cptr;
int* iptr;

值类型（Value types）：
直接给值类型变量分配一个值。
装箱（值类型—>object对象类型），拆箱（object对象类型—>值类型）
引用类型（Reference types）：
引用类型变量中存储的是值（实际内容）的引用。
包括：对象类型，动态类型，字符串类型，类，接口，委托。
指针类型（Pointer types）：
和C和C++代码交互、使用非托管代码时，使用指针较多。

1.2、变量

定义

在这里插入图片描述

1.3、常量

定义

using System;

namespace c.biancheng.net
{
    class Demo
    {
        static void Main(string[] args){
            const double pi = 3.14;     // 定义一个常量
           
            double r;
            Console.WriteLine("本程序可以计算圆的面积，请输入一个数字作为圆的半径: ");
            r = Convert.ToDouble(Console.ReadLine());
           
            double areaCircle = pi * r * r;
            Console.WriteLine("半径为: {0}, 圆的面积为: {1}", r, areaCircle);
            Console.ReadKey();
        }
    }
}

1.4、运算符

算术运算符
在这里插入图片描述

关系运算符
在这里插入图片描述

逻辑运算符
在这里插入图片描述
位运算符
赋值运算符

1.5、判断

if 语句

if … else语句

嵌套 if 语句

switch 语句

switch(expression){
    case constant-expression  :
       statement(s);
       break; 
    case constant-expression  :
       statement(s);
       break; 
  
    /* 您可以有任意数量的 case 语句 */
    default : /* 可选的 */
       statement(s);
       break; 
}

嵌套 switch 语句

条件运算符

1.6、循环

while 循环

  //--------------------------while循环---------------------------------

            Console.Write("\n" + "while循环" + "\n");
            int a = 1;
            while (a<10)
            {
                Console.Write(a + "     ");
                a++;             
            }

for/foreach 循环

  //---------------------------for循环--------------------------------

            Console.Write("for循环"+"\n");
            for (int i = 1; i < 10; i++)
            {
                Console.Write(i + "     ");
            }
 //----------------------------foreach循环-------------------------------

            Console.Write("\n"+"foreach循环" + "\n");
            int[] d = new int[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9};
            foreach (var item in d)
            {
                Console.Write(item + "     ");
            }

do … while 循环

 //-------------------------do...while循环----------------------------------

            Console.Write("\n" + "do...while循环" + "\n");
            int b = 1;
            do
            {
                Console.Write(b+ "     ");
                b++;
            } while (b < 10);

goto

        
            //--------------------------goto---------------------------------

            Console.Write("\n" + "goto" + "\n");
            int c = 1;

            aaa: //aaa是一个标签 在语句前面声明了标签，goto才能调用

            {
                if (c < 10)
                {
                    Console.Write(c + "     ");
                    c++;
                    goto aaa;
                }
            }
            Console.ReadLine();

嵌套循环
break 语句
continue 语句

1.7、数组

声明

int[] array = new int[5];

array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 4;
array[4] = 5;

for (int i = 0; i < array.Length; i++)
{
    Console.WriteLine(array[i]);
}

初始化
赋值
访问
遍历
多维数组
Array与ArrayList的区别

1、Array数组可以包含基本类型和对象类型；ArrayList只能包含对象类型
2、Array数组的空间是固定的，要事前确定合适的空间大小；ArrayList的空间是动态增长的
3、ArrayList的许多方法都是在内部数组的基础上直接调用Array的对应方法。

1.8、枚举

枚举是一个值类型，包含一组命名的常量，枚举类型用 enum 关键字定义
声明
访问
与int、string的转换**
判断枚举是否包含id

public enum Color
{
    Red,
    Green,
    Blue    // 注意最后一个常量值没有逗号
}

Color c1  = Color.Red;
Console.WriteLine( c1 );
 
// 控制台输出
// Red

1.9、字符串

字符串比较
字符串替换
字符串连接
判断是否含有字符串
复制字符串
判断是否是以某个字符串结尾
判断是否是以某个字符串开头
字符串判等
字符串格式化
求索引
字符串判空
使用分隔符连接字符串数组
使用分隔符分割字符串
插入字符串
移除字符串
转char[]
大小写转换
去除前后空白字符

1,CompareTo()方法，比较字符串的内容
2,Replace()用另一个字符或者字符串替换字符串中给定的字符或者字符串
3,Split()在出现给定字符的地方，把字符串拆分称一个字符串数组
4,SubString()在字符串中检索给定位置的子字符串
5,ToLower()把字符串转换成小写形式
6,ToUpper()把字符串转换成大写形式
7,Trim()删除首尾的空白
8,Concat()方法，合并字符串
9,CopyTo()方法，把字符串中指定的字符复制到一个数组中
10,Format()方法，格式化字符串
11,IndexOf()方法，取得字符串第一次出现某个给定字符串或者字符的位置
12,IndexOfAny()方法，
13,Insert()把一个字符串实例插入到另一个字符串实例的制定索引处
14,Join()合并字符串数组，创建一个新字符串

1.10、命名空间

定义
using
嵌套命名空间

namespace A{
	namespace B{
		namespace C{
		   ///
		}

   }

}


namespace A.B.C{

}

1.11、类

定义

class（类），是面向对象中的概念，是面向对象编程的基础。类是对现实生活中一类具有共同特征的事务的抽象，用来清晰管理你的行为。

class Program
{
    private int age; // 字段
    public int Age { get; set; }; // 属性
    public Program (age) // 构造函数
    {
      this.age = age;
    }
    
    public int Next() // 方法
    {  
      return age + 1;
    }
 }

# 创建类
Program p = new Program(22);
Program p = new Program() { Age = 22 };

1、public ：无限制；
2、internal ：只允许在同一程序集内访问；
3、protected ：只允许当前类和派生类访问；
4、protected internal ：只允许同一程序集内的当前类和派生类访问；
5、private ：只能在当前类中访问；

构造函数

1.构造函数的命名必须和类名完全相同;而一般方法则不能和类名相同.
2.构造函数的功能主要用于在类的对象创建时定义初始化的状态.它没有返回值,也不能用void来修饰.这就保证了它不仅什么也不用自动返回,而且根本不能有任何选择.而其他方法都有返回值.即使是void返回值,尽管方法体本身不会自动返回什么,但仍然可以让它返回一些东西,而这些东西可能是不安全的.
3.构造函数不能被直接调用,必须通过new运算符在创建对象时才会自动调用,一般方法在程序执行到它的时候被调用.
4.当定义一个类定义的时候，通常情况下都会显示该类的构造函数,并在函数中指定初始化的工作也可省略不去Java编译器会提供一个默认的构造函数.此默认构造函数是不带参数的.而一般方法不存在这一特点
5.构造函数是特殊的成员函数，函数体可以在类体内，也可写在类体外；
6.构造函数被声明为公有函数，但它不能像其他成员函数那样被显式调用，它是在定义对象的同时被调用的。

成员函数

是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。
类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。
成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。

析构函数

名字和类名相同，在前面加‘~’, 没有参数和返回值，一个类最多只能有一个析构函数
析构函数对象消亡时即自动被调用。可以定义析构函数来在对象消亡前做善后工作，比如释放分配的空间等
如果定义类时没写析构函数，则编译器自动生成缺省析构函数。缺省析构函数什么也不做

静态成员

在成员前面加上static关键字修饰，可以使其成为静态成员。
静态成员通过类名访问，无法通过实例访问。
静态成员和实例成员不能重名（因为变量是可以和它自己的类名同名，如果同名会无法区分）

class 猫
{
	public int 身高;
	public int 体重;
	public static int 腿的数量;
}

密封类

密封类是类的一种，用sealed修饰，不能用作基类。主要用于防止派生。

静态类

静态成员又叫类成员，是指在成员类型或返回值类型前使用static关键字修饰的变量或方法。在C#中，能够声明为静态成员的类成员包含静态成员、静态属性、静态方法、构造函数、运算符、事件等类成员。常量和索引器不能声明为静态成员。

1.12、结构体

定义

概念：C#的结构体类型（或称为结构）是用户自定义类型的一种，它为用户将实际应用中数据类型不同，但互相联系的数据看作一个整体提供了类型支持。

public struct Student//结构体类型名
{
	 //各种成员...:
	 
	 //成员定义格式为: 访问修饰符 成员类型 成员名称
	 //例:
	 public string name;
	 int age;
}

如果在定义结构体时，某个数据成员之前没有public访问修饰符，则结构体类型变量不能访问这个数据成员。(如上面结构体的age变量是不能被访问的)

结构体类型的定义是借助struct关键字向编译器声明了一种新的数据类型；对于该数据类型并没有分配相应的存储空间，因此不能直接对结构体中的变量成员进行访问，赋值等操作；只能在其被实例化之后才可以对其进行操作。

结构是密封的、不能继承的。

特点

类与结构体的区别

相同点
都包含字段,属性,方法
访问修饰符相同,可以用相同的访问修饰符
都是通过关键字new实例化对象
结构体和类大体上真的非常相似,但是不应该出有两个一模一样的东西对吧

不同点
结构体是值类型,类是引用类型,结构体在栈上开辟空间(int,float这些数据类型都是struct结构体,但是string是class类)
关键字不同----枚举关键字struct,类关键字class
构造方法 —1. 结构体中不允许写无参构造
2.结构体的有参构造函数,必须给所有的字段进行赋值
3.结构体始终包含一个public权限的无参构造方法(始终自带一个,你不写它也有)
析构方法—结构体中不允许写析构方法
继承关系不同—结构体只有一个父类Object,不能被其他结构体和类继承,也不能继承其他结构体和类

【结构体和类区别】
结构体是值类型，类是引用类型
结构体存在栈中，类存在堆中
结构体成员不能使用protected访问修饰符，而类可以
结构体成员变量申明不能指定初始值，而类可以
结构体不能申明无参的构造函数，而类可以
结构体申明有参构造函数后，无参构造不会被顶掉
结构体不能申明析构函数，而类可以
结构体不能被继承，而类可以
结构体需要在构造函数中初始化所有成员变量，而类随意
结构体不能被静态static修饰（不存在静态结构体），而类可以

1.13、接口

定义
在 C# 语言中，类之间的继承关系仅支持单重继承，而接口是为了实现多重继承关系设计的。

一个类能同时实现多个接口，还能在实现接口的同时再继承其他类，并且接口之间也可以继承。

接口定义了所有类继承接口时应遵循的语法合同。接口定义了语法合同 “是什么” 部分，派生类定义了语法合同 “怎么做” 部分。接口定义了属性、方法和事件，这些都是接口的成员。接口只包含了成员的声明。成员的定义是派生类的责任。接口提供了派生类应遵循的标准结构

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


interface 接口名称
{
    接口成员;
}

继承
（1）继承的概念
继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。
当创建一个类时，我们不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。
这个已有的类被称为的基类，也叫父类，这个新的类被称为派生类，也叫子类。
继承的思想实现了属于（IS-A）关系。例如，哺乳动物属于（IS-A）动物，狗属于（IS-A）哺乳动物，因此狗属于（IS-A）动物。

C# 继承的特点:
①派生类是对基类的扩展，派生类可以添加新的成员，但不能移除已经继承的成员的定义。
②继承是可以传递的。如果 C 从 B 中派生，B 又从 A 中派生，那么 C 不仅继承了 B 中声明的成员，同样也继承了 A 中声明的成员。
③构造函数和析构函数不能被继承，除此之外其他成员能被继承。基类中成员的访问方式只能决定派生类能否访问它们。private protected public
④派生类如果定义了与继承而来的成员同名的新成员，那么就可以覆盖已继承的成员，但这并不是删除了这些成员，只是不能再访问这些成员。
⑤类可以定义虚方法、虚属性及虚索引指示器，它的派生类能够重载这些成员，从而使类可以展示出多态性。
⑥派生类只能从一个类中继承，可以通过接口来实现多重继承。

 class Animial
    {
        public string name;
        public int age;
        public string  love;
        public void Fisft()
        {
            Console.WriteLine("吃饭不是为了吃,关键是气氛搞起来!");
        }
        public void Second()
        {
            Console.WriteLine("经常被自己的聪明所秀到!");
        }
    }

 class Dog:Animial
    {
    }

 class Program
    {
        static void Main(string[] args)
        {
            Dog dog = new Dog();
            dog.name = "哈士奇";
            dog.age = 02;
            dog.love = "拆家,搞事情,瞪眼睛";
            Console.WriteLine("我的名字叫{0},我今年{1}岁啦,我的爱好是{2}", dog.name, dog.age, dog.love);
            Console.ReadLine();
            dog.Fisft();
            Console.ReadLine();
            dog.Second();
            Console.ReadLine();
        }
    }

1.17、多态性

函数重载

运算符重载

抽象类

虚方法

1.18、运算符重载

定义
运算符重载：通过特定的语法，是某些运算符可以具备特殊的功能。关键字operator，修饰符必须为public static。

【注意事项】
1、参数的数量一定要和这个运算符操作的数量匹配。
2、参数类型和返回值类型可以随意设置，但要合情合理。
3、可以重载的运算符有：算术运算符（+、-、*、/、++、–）、关系运算符（>、<、>=、<=、==、!=）、逻辑运算符（&、|、!、^）、位运算符（~）。
4、关系运算符如果想重载，那么必须要成对的重载，例如：重载了>，则必须重载<。
5、不可被重载的运算符有：赋值运算符、逻辑运算符中的（&&、||）。
执行

using System;

public  struct Point
{
    public double x;
    public double y;
    public Point(double x,double y)
    {
        this.x = x;
        this.y = y;
    }
//运算符重载，使加号具有新的功能
//可以实现两个Point对象直接相加，得到一个新的点
    public static Point operator +(Point p1,Point p2)
    {
        return new Point(p1.x + p2.x, p1.y + p2.y);
    }
    //参数类型可以不相同
    public static Point operator + (Point p1,int a)
    {
        return new Point(p1.x + a, p1.y + a);
    }
//*号是二元运算符，因此必须有两个参数
    public static Point operator *(Point p1,Point p2)
    {
        return new Point(1, 1);
    }
//-号的身份有两种：1是加减乘除的减号，2是负号。为前者时是二元运算符，为后者是一元运算符。
    public static Point operator - (Point p1)
    {
        return new Point(1, 1);
    }
    //【重载--运算符】练习
    public static Point operator --(Point p1)
    {
        return new Point(p1.x-1,p1.y-1);
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Point p1 = new Point(1, 2);
        Point p2 = new Point(2, 3);
        Point p = p1 + p2;
        //【重载--运算符】练习
        Point p3 = new Point(1, 3);
        p3--;
        Console.WriteLine(p3.x);
        Console.WriteLine(p3.x);
        Console.WriteLine(p3.y);
        p3 = new Point(1, 3);
        --p3;
        Console.WriteLine(p3.x);
        Console.WriteLine(p3.y);
    }
}

1.19、IO操作

File类

File类的方法
【创建】文件：File.Create(@“文件路径”);
【删除】文件（彻底删除）：File.Delete(@“文件路径”);
【复制】文件内容：File.Copy(被复制文件路径,新文件路径);
【剪切】文件：File.Move(被剪切文件路径,新文件路径)

Directory类

Directory.GetFiles（string path）返回当前目录下的所有文件的绝对路径，但是不扫描子目录。
Directory.GetFiles（string path ， string fileName ，SearchOption so）返回当前目录下的名为fileName文件的绝对路径，通过SearchOption 参数判断是否需要扫描子目录。

#C#的System.IO.Directory可以新建目录、删除目录、移动目录、判断目录是否存在。
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WindowsFormsApp3
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnCreate_Click(object sender, EventArgs e)
        {
            string dir = Environment.CurrentDirectory + @"\test";
            string dest = Environment.CurrentDirectory + @"\dest";

            if(!Directory.Exists(dir))
            {
                Directory.CreateDirectory(dir);
                MessageBox.Show("目录创建成功！");
            }
            else
            {
                MessageBox.Show("目录已存在！");
            }

            if (Directory.Exists(dir))
            {
                if (Directory.Exists(dest))
                    Directory.Delete(dest);
                Directory.Move(dir, dest);
            }
            MessageBox.Show("目录创建时间：" + Directory.GetCreationTime(dest).ToString());
        }
    }
}

Path类

string filePath = "D:\\Program\\Test\\Config.txt";

#下面是Path类中的一些常用方法及执行的结果：

Path.GetFullPath(filePath);   //执行结果为==>"D:\\Program\\Test\\Config.txt";

Path.GetDirectoryName(filePath); //执行结果为==>D:\\Program\\Test

Path.GetFileName(filePath);  //执行结果为==>Config.txt

Path.GetFileNameWithoutExtension(filePath); //执行结果为==>Config

Path.GetExtension(filePath); //执行结果为==>.txt

Path.GetPathRoot(filePath); //执行结果为==>D:\