C# 基础
主要包括：基类、常量、变量、数据类型、String类、new的用法、类型转换、进制转换、装箱与拆箱、预处理器指令、final
基类
1、C#中所有类型的基类是什么？
答：在.NET CTS(Common TypeSystem)中，每一个类型都直接或间接继承自Object类，所有这些类型其实都包含于命名空间System中，所以C#中所有类型的基类是System.Object。CTS中所定义的每种类型，如果不是引用类型，那么就是值类型。引用类型直接继承自Object，所有值类型直接继承自ValueType，ValueType又继承自Object。
.NET中引用类型包括：Class, Interface, Array,String, Delegate等，除此之外的那些类型都是值类型。
2、C#的基类都有哪些方法
在C#中，Object类型是所有类型的根。Object类型中一共有8个方法，重载的方法没有算进来：
构造函数Object()、ToString()函数、GetHashCode函数、
Equals函数、ReferenceEquals函数、
Finalize函数、GetType()函数、MemberWiseClone()函数
下面一一来看看这些方法。
1、构造函数 public Object()
直接使用new Object()可以用来创建对象；如果非Object类型，则在该类型的构造函数被调用时，该函数自动被调用。
2、ToString()方法：是获取对象字符串表示的一种快捷方式。当只需要快速获取对象的内容，以进行调试时，就可以使用这个方法。
3、GetHashCode()方法：用作特定类型的哈希函数，快速生成一个与对象的值相对应的数字（哈希代码）。此方法适用于哈希算法和诸如哈希表之类的数据结构。
4、Equals()和ReferenceEquals()方法：
Equals用来检测两个对象是否相等，即两个对象的内容是否相等，区分大小写。
ReferenceEquals判断两个引用是否引用类的同一个实例。从描述也可以看出来，如果参数是值类型，则会装箱，比较的是装箱后的对象实例。
==用于比较引用和比较基本数据类型时具有不同的功能：
比较基本数据类型，如果两个值相同，则结果为true
而在比较引用时，如果引用指向内存中的同一对象，结果为true
5、Finalize()方法：允许对象在垃圾回收回收该对象之前 尝试释放资源并执行其它清理操作。
6、GetType()方法：获取当前实例的确切运行时类型。
7、MemberWiseClone()方法：创建一个浅表副本，方法是创建一个新对象，然后将当前对象的非静态字段复制到该新对象。
如果字段是值类型的，则对该字段执行逐位复制。如果字段是引用类型，则复制引用但不复制引用的对象；因此，原始对象及其复本引用同一对象。
常量(const readonly)
C#有两种常量类型：编译时常量(用const声明)与运行时常量(用readonly声明)
编译时常量可以在方法内声明，而运行时常量不可以。
编译时常量只能是原子类型(内置整型、浮点型、枚举、string等)，而运行时常量可以是任何类型。
最重要的是Readonly类型变量在运行时被解释，IL会生成对应对象的常引用 ，而const变量会被IL生成对应的值，而这样会对后期的维护造成不便。
编译时常量const在编译的时候会被直接写成对应的值，而不会再从原来的类中读取。这样会产生问题。
如果A类定义了常量, B类使用了常量, 并且都进行了编译, 当A类的源码被改动了, 常量的值发生了变化, 我们对A类进行重新编译, 但是没有对B进行重新编译, 那么B类中用到的是原来A类中的常量值, 即旧值, 这样就导致了风险的产生 。
但是理论上是这样的，实际上操作中IDE会自动帮我们重新编译B类， 所以我试着操作了几次，并没有发生这样的风险。但是这个风险的确是存在的。
如下代码:
public class UsefulValues { public static readonly int StartValue = 5; public const int EndValue = 10; }
而在另一程序集，你引用了这些值:
for(int i = UsefulValues.StartValue;i<UsefulValues.EndValue; i++) Console.WriteLine("value is {0}", i);
然后经过一段事件你对原程序集（UsefulValues）进行了修改，修改后:
public class UsefulValues { public static readonly int StartValue = 105; public const int EndValue = 120; }
此时你希望输出是
value is 105
value is 106
...
value is 119
而实际将什么都不输出，因为此时的for循环已经是如下代码:
for(int i = UsefulValues.StartValue;i<10; i++) Console.WriteLine("value is {0}", i);
const变量会比readonly变量要稍微快一点，因为IL是直接为其生成常量字符串或数字，而readonly的灵活性要更好，因此我们应当偏爱readonly。
装箱和拆箱
其实就是数据类型转换。装箱是把值类型转换为引用类型的过程，是隐式的，相反的过程就是拆箱，是显式的。
装箱分3部：
1）分配内存空间。包括要装箱的值类型的空间、方法表、SynBlockIndex，其中后两者用来管理引用对象。
2）值复制。把堆栈中要装箱的值复制到堆上。
3）返回引用对象的引用。
拆箱也分3部:
1) 检查类型，确保引用类型是装箱的结果。
2）指针返回，返回要拆箱的引用类型中的值的地址。
3）字段拷贝，把引用类型中的字段拷贝到堆栈中。
new关键字用法
1、new 运算符：用于创建对象和调用构造函数。
2、new 修饰符：可以显式隐藏从基类继承的成员。
当基类和子类中都具有相同签名的方法声明，而基类方法没有使用virtual关键字时，子类方法便会隐藏基类方法。子类隐藏基类的方式时，编译器会进行提示：若是有意隐藏基类方法，（子类）请使用关键字new。
class TestBaseClass { public void VirtualMethod() { Console.WriteLine("This Is Base Class's Virtual Method"); } } class TestDerivedClass:TestBaseClass { public new void VirtualMethod()//使用new关键字告诉编译器隐藏基类方法 { Console.WriteLine("This Is Derived Class's Virtual Method"); }
3、new约束：用于在泛型声明中约束可能用作类型参数的类型。
public class Tester<T> where T:new() { }
where T : class T必须是一个类（class）类型
where T : new() T必须要有一个无参构造函数
进制转换
int 10进制转16进制
int.ToString("x"); //字母小写
int.ToString("X"); //字母大写
或者
// 方式1，无法进行自动补0 string data1 = Convert.ToString(17194, 16); // 432A string data2 = Convert.ToString(0, 16); // 0 // 方式2，自动补0 string data3 = 17194.ToString("X4"); // 432A string data4 = 0.ToString("X2"); // 00 string data5 = 0.ToString("X4"); // 0000
X代表16进制；X后面的数字每次的数据位数，当位数不足时自动补0
xx进制转10进制（int）
1、二进制转10进制：System.Convert.ToInt32(s, 2);// s为string类型 以“1010”为例，输出为10
2、16进制转10进制：System.Convert.ToInt32("0x41", 16);//以"0x41"为例，输出为65
xx进制转2进制（string输出）
1、10进制转2进制：System.Convert.ToString(d, 2);// d为int类型 以4为例，输出为100
2、16进制转2进制：System.Convert.ToString(d, 2);// d为int类型 以0X14为例，输出为10100
类型转换
int类型转换方法
Convert.ToInt32、int.Parse（Int32.Parse）、int.TryParse、(int) 四者都可以解释为将类型转换为 int，那它们的区别是什么呢？
- Convert.ToInt32 与 int.Parse 较为类似，实际上 Convert.ToInt32 内部调用了 int.Parse：
- Convert.ToInt32 参数为 null 时，返回 0； 参数为 "" 或者" "时，抛出异常。Convert.ToInt32 可以转换的类型较多；
- int.Parse 参数为 null 或者 "" 时，抛出异常。int.Parse 只能转换数字类型的字符串。
- int.TryParse 与 int.Parse 又较为类似，但它不会产生异常，转换成功返回 true，转换失败返回 false。最后一个参数为输出值，如果转换失败，输出值为 0。
- (int) 属 cast 转换，只能将其它数字类型转换成 int 类型，它不能转换字符串，否则报异常。
as、is、cast
请使用as来进行两个对象之间的类型转换（转换失败时返回null，不会引发异常）因为它更安全、更有效。
- as 运算符只执行引用转换和装箱转换，不能用于值类型，as 运算符无法执行其他转换。
as与is操作符不能执行任何的用户自定义类型转换，它从不自己构造新对象。
- Cast则可实现类型转换，它会转换一个对象为请求的类型，如果转换一个高精度类型到低精度类型，则可能会丢失信息。
值类型只能用Cast，而此时会产生装箱/拆箱操作，而此时一般建议会使用is操作符来先判断。如:
object o = Factory.GetValue(); int i = 0; if(o is int) i=(int)o;
is操作符应该用在不能使用as操作符进行转换的时候。is检查对象是否与给定类型是否相同，返回true/false。
好的面向对象设计应当尽量避免进行类型转换，但是有时你不得不进行类型转换的时候，使用as和is操作符可以更清晰地表达你的目的。
C# String类型转换成Char类型
string str="1";
char c;
c=Convert.ToChar(str);
隐式、显示转换
short s1 = 1; s1 = s1 + 1; //报错：int转为short，不能隐式转换， 缺少强制转换
而 short s1=1;s1+=1; //正确，是因为编译的时候，会自动转换。即 s1=(short)(s1+1);
用反编译工具Reflector看一下就知道了
预处理器指令
#if / #endif 及其改进
#if/#endif太容易滥用，创建的代码也很难理解和调试。C#增加了条件特性来指示一个方法是否应该被调用。它比#if/#endif更清晰。
1、#if/#endif方式：
private void CheckStateBad() { // The Old way: #if DEBUG Trace.WriteLine("Entering CheckState for Person"); // Grab the name of the calling routine: string methodName = new StackTrace().GetFrame(1).GetMethod().Name; Debug.Assert(lastName != null, methodName, "Last Name cannot be null"); Debug.Assert(lastName.Length > 0, methodName, "Last Name cannot be blank"); Debug.Assert(firstName != null, methodName, "First Name cannot be null"); Debug.Assert(firstName.Length > 0, methodName, "First Name cannot be blank"); Trace.WriteLine("Exiting CheckState for Person"); #endif }
如果在Release模式编译生成，此方法将会是一个空方法。如果频繁地调用该方法也会产生一部分开销。而有时因为#if/#endif的位置不当，Release编译时会产生一些错误。
2、条件特性方式：
[Conditional("DEBUG")]
private void CheckStateBad()
{
...
}
该特性告诉编译器该方法只有在检测到有DEBUG环境变量时有效。
条件特性相比#if/#endif会生成更有效的IL代码。
final, finally, finalize的区别
final，如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。
finally，在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入finally 块（如果有的话）。
finalize，方法名。Finallize表示是object类一个方法，在垃圾回收机制中执行的时候会被调用被回收对象的方法。
C#中的对象释放
c# 自身对于所有托管对象(managed object)都是可以不用程序员去干预的（注：可以不用干预，当然资源耗费很多且必要时也可以去做一些干预来提升程序性能，比如通过代码部分控制垃圾回收），但对于非托管资源（文件、流、数据库连接、GDI+对象、COM对象等等）都需要程序来控制资源的释放。
释放资源主要有两种方式：
- 其一是对象实现IDisposable接口，由程序员调用IDisposable.Dispose()方法来释放资源；
- 其二是通过重写继承自Object对象的虚方法Finalize()来释放资源。
（一）IDisposable
public interface IDisposable { void Dispose(); }
说明：垃圾回收器GC不支持IDisposable接口，不能通过自动的垃圾回收机制或手工调用GC.Collect()方法来调用Disposable方法。
重要点：只有通过程序显式或非显式调用Dispose方法，才会通过该方法释放资源。所谓显示调用，就是直接在代码中写Dispose()来带调用。关于隐式调用，常见的有两种：
（1）其一就是使用using关键字
using(StreamWriter sw= new StreamWriter(NewFilePath,true)) { //处理完代码后，会调用Dispose方法。即使发生了异常，也会调用Dispose方法。本质上中间代码是转换为try{}finally{}的，而Dispose方法是在finally{}中调用的，所以不担心因为异常而没有调用到Dispose方法 }
（2）关于Dispose方法的隐式调用，另一种常见的是对Dispose的间接调用而已，常见的是一些类库中的别名调用。比如
FileSream fs=new FileStream("abc.txt“，FileMode.OpenOrCreate); //dosomething fs.close(); //close（）释放资源，实质上就是隐式调用了Dispose()释放了资源。
注：如果不调用close()而调用Dispose()，其效果是一样的。
（二）Finalize（）方法与析构函数~MyClass()
要点：Finalize是由Object基类定义的虚方法；垃圾回收的时候GC会调用Finalize()方法；在自己的程序中，通过c#是不能直接重载Finalize()方法的，会出现编译错误，what？why？how？那怎么办呢？答案是：用析构函数~MyClass()来代替Finalize()方法，在析构函数中写释放资源的代码。
class MyClass { protected override void Finalize(){} //是不能编译的，编译不通过 //为什么会这样呢。Finalize方法本来就是Object类定义的受保护的虚方法（protected virtual)，这里却不能重写？？？ //不知道微软是怎么处理的，但就是不能继承，咱也没有办法的，那就不要这么做了。微软要我们直接写析构函数~MyClass(){} } class MyClass { protected override void Finalize(){} //是不能编译的，编译不通过 ~MyClass() { MyReleaseSourceCode; //在这里写释放资源的代码 } }
经过仔细查证，发现：析构函数经过编译后，在中间代码中就会转换为Finalize()方法，所以c#的析构函数本质上就是Finalize()方法。但是，通过析构函数转换为Finalize()方法的过程中，编译器会添加一些额外的代码。通过ildasm.exe查看c#析构函数编译过的代码，可以发现编译器加入了一些错误检测代码。分析中间码可以发现，程序员自己写的代码都会放在中间代码的try{}块中，另外在中间代码的finally块中放置了一些代码，保证基类的Finalize方法总是被执行。
