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;
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.8、枚举
枚举是一个值类型， 包含一组命名的常量， 枚举类型用 enum 关键字定义
声明
访问
与int、string的转换**
判断枚举是否包含id
public enum Color
{
Red,
Green,
Blue // 注意最后一个常量值没有逗号
}
Color c1 = Color.Red;
Console.WriteLine( c1 );
// 控制台输出
// Red
1.9、字符串
字符串比较
字符串替换
字符串连接
判断是否含有字符串
复制字符串
判断是否是以某个字符串结尾
判断是否是以某个字符串开头
字符串判等
字符串格式化
求索引
字符串判空
使用分隔符连接字符串数组
使用分隔符分割字符串
插入字符串
移除字符串
转char[]
大小写转换
去除前后空白字符
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 };
构造函数
成员函数
析构函数
静态成员
在成员前面加上static关键字修饰，可以使其成为静态成员。
静态成员通过类名访问，无法通过实例访问。
静态成员和实例成员不能重名（因为变量是可以和它自己的类名同名，如果同名会无法区分）
class 猫
{
public int 身高;
public int 体重;
public static int 腿的数量;
}
密封类
静态类
1.12、结构体
定义
概念：C#的结构体类型（或称为结构）是用户自定义类型的一种， 它为用户将实际应用中数据类型不同，但互相联系的数据看作 一个整体提供了类型支持。
public struct Student//结构体类型名
{
//各种成员...:
//成员定义格式为: 访问修饰符 成员类型 成员名称
//例:
public string name;
int age;
}
如果在定义结构体时，某个数据成员之前没有public访问修饰符，则结构体类型变量不能访问这个数据成员。(如上面结构体的age变量是不能被访问的)
结构体类型的定义是借助struct关键字向编译器声明了一种新的数据类型；对于该数据类型并没有分配相应的存储空间，因此不能直接对结构体中的变量成员进行访问，赋值等操作；只能在其被实例化之后才可以对其进行操作。
结构是密封的、不能继承的。
特点
类与结构体的区别
1.13、接口
定义
在 C# 语言中，类之间的继承关系仅支持单重继承，而接口是为了实现多重继承关系设计的。
一个类能同时实现多个接口，还能在实现接口的同时再继承其他类，并且接口之间也可以继承。
接口定义了所有类继承接口时应遵循的语法合同。接口定义了语法合同 “是什么” 部分，派生类定义了语法合同 “怎么做” 部分。接口定义了属性、方法和事件，这些都是接口的成员。接口只包含了成员的声明。成员的定义是派生类的责任。接口提供了派生类应遵循的标准结构
interface 接口名称
{
接口成员;
}
继承
（1）继承的概念
继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。
当创建一个类时，我们不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。
这个已有的类被称为的基类，也叫父类，这个新的类被称为派生类，也叫子类。
继承的思想实现了属于（IS-A）关系。例如，哺乳动物属于（IS-A）动物，狗属于（IS-A）哺乳动物，因此狗属于（IS-A）动物。
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。
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类
Directory类
#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:\
FileStream类
StreamReader类
StreamWriter类
BinaryReader类
BinaryWriter类
1.20、预处理
#define
#undef
#if
#else
#elif
#endif
#region
#endregion
1.21、异常处理
try、catch、finally 、throw
异常类
自定义异常
