——表达式
double和float的比较
关于double类型之间或者float类型之间的数据：
有时是无法正确比较大小的，原因很简单，就像在十进制中，1/3得到的是0.33333333333，在二进制存储中也会出现这种无限循环的情况，比如说对于1/10,在十进制中是0.1，但是对于二进制就是一个无限循环长的小数，因此，在double或者float中会因为精度问题舍去一些位数，造成比较不准确，因此，对于需要精确计算的情况，比如银行货币，建议不使用double或者float，而使用decimal来计算。
比如下面这样计算：
class Program
{
static void Main(string[] args)
{
double a = 0.0;
while (a < 10)
{
a += 0.1;
Console.WriteLine(a.ToString());
if (a == 6.0)
{
Console.WriteLine("is 6.0");
break;
}
}
Console.ReadLine();
}
}
我们可以这样做，设置一个精度值，比较两个double类型相减的绝对值，如果小于这个精度值，判定为相等，双精度的精度值可以是1E-6,也就是1乘以10的6次方。
class Program
{
static void Main(string[] args)
{
double a = 0.0;
while (a < 10)
{
a += 0.1;
Console.WriteLine(a.ToString());
if (Math.Abs(a - 6.0) < 1E-6)
{
Console.WriteLine("is 6.0");
break;
}
}
Console.ReadLine();
}
}
浅比较和深比较
对于一些引用类型的比较，比较它们是否相等，比较的是它们的引用是否相等，也就是，如果两个引用指向堆中同一块内存，才会定位相等，这叫做浅比较。
对于字符串或者委托，比较的是他们包含的数据是否相等，即使引用指向不同内存，但是只要实际数据相等，就会判定为相等，这叫做深比较。
自定义
自定义类型转换和运算法都需要使用和operator（翻译为：操作员）关键字。
自定义类型转换
除了系统定义的隐式转换或者显示转换，我们还可以自己定义转换，比如系统无法将一个Base类对象转换为string或者int，但是我们可以自己定义，让一个Base类隐式转换为string，或者让Base类显示转换为int。
需要使用implicit（翻译为：含蓄的）和explicit（翻译为：明确的）两个关键字，在需要转换的类中自定义转换。
class Base
{
string str = "this is base";
int val = 10;
public static implicit operator string(Base b)//implicit，自定义可隐式转换为string
{
return b.str;
}
public static explicit operator int(Base b)//explicit，自定义可显示转换为int
{
return b.val;
}
}
class Program
{
static void Main(string[] args)
{
Base b = new Base();
string s = b; //隐式转换
int i = (int)b; //强制转换
Console.WriteLine(s); //打印this is base
Console.WriteLine(i); //打印10
Console.ReadLine();
}
}
自定义运算符
和自定义转换类型一样，运算符也可以自定义，是普通的运算符可以完成奇怪的运算
class Base
{
string str = "this is base";
int val = 10;
public static int operator - (Base b1,int val) //自定义-运算符，返回值为int
{
return b1.val * val;
}
public static string operator + (Base b) //自定义+运算符，返回值为string，
{
return b.str + " sum";
}
}
class Program
{
static void Main(string[] args)
{
Base b1 = new Base();
Base b2 = new Base();
int val = b1 - 10;
string str = + b1;
Console.WriteLine(val); //打印100
Console.WriteLine(str); //打印this is base sum
Console.ReadLine();
}
}
typeof运算符
typeof可以返回用于运算的类的System.Type对象，该对象会包含用于运算的类的所有信息，也可以使用GetType方法代替，效果和typeof运算符是一样的。
class Base
{
public string str = "this is base";
int val = 10;
public void Fun()
{
Console.WriteLine("fun");
}
void Method()
{
Console.WriteLine("method");
}
}
class Program
{
static void Main(string[] args)
{
Type t = typeof(Base); //返回包含Base类信息的Type对象
System.Reflection.FieldInfo[] fields = t.GetFields(); //获取Type对象保存的类中所有的字段
System.Reflection.MethodInfo[] methods = t.GetMethods(); //获取Type对象保存的类中所有的方法
foreach (var item in fields)
{
Console.WriteLine("Field: " + item.Name);
}
foreach (var item in methods)
{
Console.WriteLine("Methods: " + item.Name);
}
Console.ReadLine();
}
}
——语句
标签和goto语句
了解就可以，不建议使用。
class Program
{
static void Main(string[] args)
{
int val = 0;
while (true)
{
val++;
if(val == 5)
{
goto cw;//在val=5的时候跳转到cw标签的语句
}
}
cw : Console.WriteLine(val);//打印5
Console.ReadLine();
}
}
using语句
注意事项using语句，不是using指令
对于非托管的资源（就是不被GC回收的资源，如System.IO.StreamReader等各种流、各种连接所分配的资源，需要显式调用Close或Dispose释放），它的作用就相当于在资源使用完之后，自动调用Dispose清理资源，不需要我们手动Close或者Dispose。前提这些使用的资源必须是实现System.IDisposable接口的。
例子如下：
class Program
{
static void Main(string[] args)
{
using (TextWriter tw = File.CreateText("Lincoin.txt"))
{
Console.WriteLine("later...");//打印这句
}
Console.ReadLine();
}
}
——结构体
结构体和类的用法很像，但是和类有许多不同的地方，需要搞懂。
结构体的位置
结构体可以写在类里面也可以写在类外面。写在类里面只能在这个类里面使用，写在类外面，别的类也可以使用。
//类外的结构体
struct OtherStruct
{
}
class Base
{
//Base类中的结构体
struct BaseStruct
{
}
}
class Child
{
OtherStruct otherStruct = new OtherStruct(); //正确
BaseStruct baseStruct = new BaseStruct(); //错误
}
结构体无法被继承
结构体是隐式的sealed无法被继承，无论是写在类外还是类里。
结构体字段不能设置初值
结构体内定义的字段不允许设置初始值。
结构体的构造函数
结构体也有构造函数，它有一个默认的无参构造函数，负责给字段初始化默认值。不允许重写这个默认构造函数，也不能被删除。可以定义其他有参的构造函数，但默认无参构造函数依然会保留。也可以定义静态的构造函数，结构体的静态构造函数和类中的静态函数用法一样，会在实例化结构体，或者使用结构体中的静态成员时系统自动调用。不能声明析构函数。
struct Struct
{
//int c = 0; //错误，不能设置字段初值，会在默认无参构造函数中自动设置为默认值
public int a;
public static int b;
//public Struct() //错误，不能重写无参构造函数
//{
//}
public Struct(int val)
{
a = val;
}
static Struct() //静态构造函数不允许使用修饰符，也不允许是用参数，（因为它系统调用，你不会有调用它的机会）
{
b = 20;
}
}
class Program
{
static void Main(string[] args)
{
Struct str1 = new Struct(10); //使用有参构造函数构造
Console.WriteLine(str1.a); //打印：10
Console.WriteLine(Struct.b); //打印：20
Struct str2 = new Struct(); //使用无参构造函数构造
Console.WriteLine(str2.a); //打印：0
Console.WriteLine(Struct.b); //打印：20
Console.ReadLine();
}
}
结构体实例的使用
如果作为成员创建结构体实例，那么可以使用new关键字，也可以不使用，不会影响后面对结构体中数据的调用，但是如果在方法中创建结构体，如果不使用new关键实例化，需要对每个结构体中的数据赋值才能使用。
struct Stu
{
//int x = 10;
public int x;
public void Fun()
{
Console.WriteLine("Fun");
}
}
class Base
{
Stu stu1;
Stu stu2 = new Stu();
public void Fun()
{
//stu1
Console.WriteLine(stu1.x); //打印0
stu1.Fun(); //打印fun
//stu2
Console.WriteLine(stu2.x); //打印0
stu2.Fun(); //打印fun
//stu3
Stu stu3;
//Console.WriteLine(stu3.x); //报错，需要对stu3.x先赋值才能使用
stu3.x = 10;
Console.WriteLine(stu3.x); //正确
//stu4
Stu stu = new Stu();
Console.WriteLine(stu.x); //正确
}
}
结构体和类的区别
1、结构体关键字为struct，类为class
2、结构体不能被继承
3、结构体是值类型
4、结构体作比较是深比较
5、结构体构造函数无论如何都会有无参构造函数，而类可以没有无参构造函数
5、如下图，cs1和cs2是类，cs1赋值给cs2，ss1和ss2是结构体，ss1赋值给ss2
——枚举
枚举声明位置的区别
枚举如果声明在类外面，那么可以被其它类访问，如果声明在类里面那么只能被该类或者该类的派生类使用，也就是说，枚举是可以被继承的。
枚举的底层类型和显示值
枚举的中的每个变量名尽管不能有重复，但是变量名对应的显示值是可以重复的，如果手动设置某个变量的显示值，那么下面的变量名对应的显示值一次加1。
也可以设置枚举变量名的显示值类型，格式是枚举名称后面加‘：’加类型，也就是说，只能设置任何整型类型。
class Base
{
public enum Color : byte //修改显示值的类型
{
red,
green = 10, //设置显示值
black,
yellow = 9, //设置显示值
pink,
blue
}
}
class Child : Base
{
public void Fun()
{
Color red = Color.red;
Color black = Color.black;
Color pink = Color.pink;
Console.WriteLine((byte)(red)); //打印0
Console.WriteLine((byte)black); //打印11
Console.WriteLine((byte)pink); //打印10
}
}
其他
可以比较两个相同枚举类型的枚举对象的大小。但是不能比较枚举类型不同的枚举对象大小，会报错。
——数组
在这儿统一一下，二维数组一维表示行，二维表示列，从上往下，从左往右这样思考。
System.Array
数组是引用类型，数组对象继承自System.Array。
Rank：返回数组的维度。
Length：返回一维数组的长度，或者返回多维数组的第一维的长度。
GetLength（）：获取指定维度的长度，0表示第一维。
Clear（）：清空数组。
Sort（）：排序数组。
IndexOf（）：返回一维数组中遇到的第一个值
Reverse（）：反转数组
GetUpperBound（）：获取指定维度的上限
Clone（）：克隆数组，需要注意，Clone函数会产生一个新的数组对象，新的引用执行该新的数组对象，如果数组是值类型，会复制原数组的值到新数组，如果是引用类型的数组，那么两个数组中的引用共用数据。
数组存储之类型和引用类型在内存上的区别
多维数组
多维数组分为矩形数组和交错数组
多维数组的同一维度不同元素长度相等。
交错数组的同一维度不同元素可以长度不等。
class Base
{
int[,] arr1 = new int[5, 4]; //这是矩形数组
int[][] arr2 = new int[5][]; //这是交错数组，注意，第二个方括号不能填长度
}
比较矩形数组和交错数组
矩形数组在堆内存中实际只有一个对象，而交错数组在内存中实际是一个一维数组，然后每个元素又指向一个新的数组对象。
在CLR中，一维数组有特定的指令用于优化，而矩形数组没有，因此，有时使用一维数组的交错数组系哦啊绿更好。
foreach
在foreach循环遍历数组时，是不能修改迭代变量（item）的，比如说值类型的数组，修改迭代变量相当于修改它的值，但是对于引用类型的数组，迭代变量保存的只是引用类型元素的引用，所以可以修改迭代变量指向的对象的实例。
