C# 基础需知

1.类型的访问控制（控制由松到严格）
public：可以被任何程序集中的任何代码调用。
internal（assembly，VB中是Friend）：可以被同一程序集中的任何代码调用。
protected(Family):可以被同一类型中和派生类型中的代码调用，不能被其他类访问。
private：只能在同一个类型中访问。
默认为internal。

2.new一个对象所进行的操作
a.从托管堆中分配指定类型所需数量字节来作为存储其对象的内存空间
b.初始对象的附加成员。每一个对象都有两个附加成员，CLR使用这两个成员来管理对象。一个为指向类方法表的指针，另一个为SyncBlockIndex。
c.传入new操作符指定的参数，调用构造函数。

3.is操作符和typeof
用来判断某个对象是否某个类型(或基类)。返回true或者false。如果对象为null，则肯定返回false。
bool b =o is object;
而typeof（）输入一个类型（而非实例），返回一个system.type的实例。

4.基元类型和FCL类型
基元类型和FCL类型有对应关系。c#语言规范中推荐使用基元类型。但Jeffrey Richter推荐使用FCL类型。
常用的一些对应有
基元类型       FCL类型                备注
byte           System.Byte
int              System.Int32
long            System.Int64
float           System.Single
double        System.Double
bool           System.Boolean

5.装箱和拆箱

C#数据类型可以分为在栈上分配内存的值类型和在堆上分配内存的引用类型.
int myIntNmer=2o`
object myolDject =myIntNumber; // Box the int
int mysecondNumber = (int)myobject; // Unbox it back into an int

装箱用于描述把一个值类型转换为引用类型。运行库会为堆上的对象创建一个临时的引用类型“箱子”。

拆箱用于描述相反的过程,其中以前装箱的值类型强制转换回值类型。这里使用术语“强制转换”,是因为这种转换是显式进行的
只能对以前装箱的变量进行拆箱。当myobject不是装箱后的int型时,如果执行最后一行代码,就会在运行期间抛出一个异常。

 

6.类（型）的成员
a.常数：常数是静态的，是属于类的而不是属于实例的，不能用this访问
public const int theConst=0;
b.readonly修饰：readonly修饰的变量是属于实例的，能够在构造函数中修改其值
c.类型构造器（静态构造函数）：初始化类型的静态字段。
static classname(){},不能用public等修饰,不能带参数。在类型第一次被访问的时候执行。
d.静态成员（static）：属于类型，不属于实例，在静态方法中不能访问非静态成员。在非静态成员中能够访问静态成员，但不能加this

7.类型的预定义特性（abstract，sealed）
abstract（VB:MustInherit）：不能被实例化，可以做基类。基类可以被实例化
sealed（VB:NotInheritable）：不能作为基类

8.字段和方法的预定义特性
a.字段预定义特性
static（VB:Shared）
readonly
b.方法预定义特性
static（VB:Shared）:静态方法，属于类型而非类的实例
virtual(VB:overridable)：当方法被调用的时候，按照对象继承链最末端的方法调用。父类的virtual和子类的override配合，就能被继承链的最末端调用，否则会按照编译时的类型调用。要被重写的（override）方法，在基类应该写virtual。
new(VB:Shadows)：不重写基类方法
override(Overrides)：重写基类方法，与基类的virtual配合
abstract(Mustoverride)
sealed(NotOverridable)

9.委托
委托相当于函数指针，用类型安全的方法来提供函数回调机制。
函数名是一个委托的实例。
a.定义委托类型
在类的内部或者类的外部，地位相当于一种类型。
public delegate void FeedBack(string arg1,string arg2);
其中，void表示该委托类型的返回值，小括号内表示该委托类型的参数
b.定义委托实例
FeedBack fb=new FeedBack(函数名);
或者先定义一个指向null的委托，再往这个委托的委托链上添加函数
FeedBack fb=null;
fb+=函数名;
或者干脆直接用函数名称作为一个委托的实例
FeedBack fb=函数名;

10.类的事件
a：定义一个事件参数类（和该类在同一个命名空间内），继承自EventAgrs
b：定义一个委托类型（和该类在同一个命名空间内） public delegate void EventHandler(object sender,EventArgs e);
c:在类里面定义事件（其实是定义一个委托）
   public event EventHandler OnEvent;(event关键字可以省略)
d:引发事件
   if(OnEvent!=null)
   {
      OnEvent(sender,e);
   }
   如果事件被注册了就不会为null
 捕获事件
    订阅：对象名.OnEvent+=new EventHandler(处理函数名称);
    取消订阅：对象名.OnEvent-=new EventHandler(处理函数名称);
    注意：只要一个对象仍然登记有另外一个对象的事件，该对象就不能被执行垃圾回收
    所以应该在必要的地方注销所有的事件注册

11.异常处理
异常处理一直是让人感到迷茫的地方，哪里应该捕获异常，哪里不应该捕获异常，捕获的异常应该如何处理，异常对程序性能的影响等等问题，是要搞清楚的问题。
异常是对程序接口隐含假设的一种违反。那么如何通知调用者违反了假设呢？答案就是抛出一个异常。
c#可以只写catch，不写小括号，表示捕捉所有的异常。可以thorw，不写抛出什么异常，代表抛出所捕获的异常。
finally内部的代码用于做一些清理工作（如关闭文件，关闭数据库链接等），即使try里面的代码抛出异常，或者try里面有return，finally的代码也会执行。可以认为向上抛出异常和return是同样级别的，而finally则在它们之前进行运行

12.接口

13.base 关键字
用于从派生类中访问基类的成员：
a.调用基类上已被其他方法重写的方法。
b.指定创建派生类实例时应调用的基类构造函数。
c.基类访问只能在构造函数、实例方法或实例属性访问器中进行。从静态方法中使用 base 关键字是错误的。

调用基类方法：
public class Person
{
    protected string ssn = "444-55-6666";
    protected string name = "John L. Malgraine";

    public virtual void GetInfo()
    {
        Console.WriteLine("Name: {0}", name);
        Console.WriteLine("SSN: {0}", ssn);
    }
}
class Employee : Person
{
    public string id = "ABC567EFG";
    public override void GetInfo()
    {
        // Calling the base class GetInfo method:
        base.GetInfo();
        Console.WriteLine("Employee ID: {0}", id);
    }
}

调用基类构造函数：
public class BaseClass
{
    int num;

    public BaseClass()
    {
        Console.WriteLine("in BaseClass()");
    }

    public BaseClass(int i)
    {
        num = i;
        Console.WriteLine("in BaseClass(int i)");
    }

    public int GetNum()
    {
        return num;
    }
}

public class DerivedClass : BaseClass
{
    // This constructor will call BaseClass.BaseClass()
    public DerivedClass() : base()
    {
    }

    // This constructor will call BaseClass.BaseClass(int i)
    public DerivedClass(int i) : base(i)
    {
    }

    static void Main()
    {
        DerivedClass md = new DerivedClass();
        DerivedClass md1 = new DerivedClass(1);
    }
}