abstract表明一个类是不完整的，只能作为其他类的一个基类。
抽象类与非抽象类的不同之处有：
1.抽象类无法直接用例子说明，且在抽象类中不能使用操作符new。
2.抽象类允许(但不需要)含有抽象成员。
3.抽象类不能被密封(密封类不能被继承)。
当一个非抽象类是从一个抽象类派生而来时，该非抽象类一定包括所有被继承抽象成员的实际执行。这样的执行是通过使抽象成员无效而得到的。
----《C#编程思想》

在类定义前面放置abstract关键字，可以将类声明为抽象类。
EXAMPLE
public abstract class A{...};
使用abstract关键字可以创建必须在派生类中实现的不完整的类和类成员。
抽象类不能实例化。抽象类的用途是提供多个派生类可共享的基类的公共定义。
例如：类库可以定义一个作为其多个函数的参数的抽象类，并要求使用该库通过创建派生类来提供自己的类实现。
抽象类也可以定义抽象方法。将abstract关键字添加到方法的返回类型的前面。
EXAMPLE
public abstract class A
{
public abstract void AA(int num);
}
抽象方法没有实现，所以方法定义后面是分好，而不是方法块。
抽象类的派生类必须实现所有抽象方法。当抽象类从基类继承虚方法时，抽象类可以使用抽象方法重写该虚方法。
EXAMPLE
public class D
{
public virtual void DoWork(int i){}
}
public abstract class E:D
{
public abstract override void DoWork(int i);
}
public class F:E
{
public override void DoWork(int i)
{
    //new implementation
}
}
如果将virtual方法声明为abstract，则该方法对于从抽象类继承的所有类而言仍然是虚方法。
抽象继承方法的类无法访问该方法的原始实现。在此情况下，抽象类可以强制派生类为虚方法提供新的方法实现。
----《MSDN 抽象类、密封类及类成员》

在C#中使用关键字abstract来定义抽象类和抽象方法。
不能初始化的类被叫做抽象类，他们只提供部分实现，但是另一个类可以继承它并且能创建他们的实例。
抽象类能够被用于类、方法、属性、索引器和事件，使用abstract在一个类声明中表示该类倾向于要作为其它类的基类成员被标识为abstract，或被包含进一个抽象类，必须被其

派生类实现。
EXAMPLE
public abstract class A
{
    public abstract void FunctionA();
    public void FunctionB()
    {
        Console.WriteLine("FunctionB");
    }
}
public class B : A
{
    public override void FunctionA()
    {
        Console.WriteLine("override FunctionA");
    }   
}
public class C
{
    static void Main(string[] args)
    {
        B b1 = new B();
        b1.FunctionA();
        b1.FunctionB();
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}
一个抽象类可以包含抽象方法和非抽象方法，当一个类继承于抽象类，那么这个派生类必须实现基类中所有的抽象方法。
但是通过声明派生类也为抽象类，可以避免所有或特定的虚拟方法的实现。这就是抽象类的部分实现。
EXAMPLE
public abstract class A
{
    public abstract void FunctionA();
    public abstract void FunctionB();
}
public abstract class B : A
{
    public override void FunctionA()
    {
        Console.WriteLine("FunctionA");
    }
}
public class C : B
{
    public override void FunctionB()
    {
        Console.WriteLine("FunctionB");
    }
}
public class D
{
    static void Main(string[] args)
    {
        C c1 = new C();
        c1.FunctionA();
        c1.FunctionB();
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}
C#中，一个抽象类可以继承非抽象类。并且，继承了基类的方法，添加新的抽象和非抽象方法是可行的。
EXAMPLE
public class A
{
    public void FunctionA()
    {
        Console.WriteLine("FunctionA");
    }
}
public abstract class B : A
{
    public abstract void FunctionB();
}
public class C : B
{
    public override void FunctionB()
    {
        Console.WriteLine("FunctionB");
    }
}
public class D
{
    static void Main(string[] args)
    {
        C c1 = new C();
        c1.FunctionA();
        c1.FunctionB();
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}
一个抽象类也能从一个接口来实现，这种情况，必须为所有的方法提供方法体，这些方法是来自接口。
EXAMPLE
public interface I1
{
    void FunctionA();
}
public abstract class A : I1
{
    public void FunctionA()
    {
        Console.WriteLine("FunctionA");
    }
}
public class B : A
{
    public void FunctionB()
    {
        Console.WriteLine("FunctionB");
    }
}
public class C : B
{
    static void Main(string[] args)
    {
        B b1 = new B();
        b1.FunctionA();
        b1.FunctionB();
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}
不能把关键字abstract和sealed一起使用，因为一个密封类不能够被抽象。
对于抽象类：
一个抽象类必须为所有的接口成员提供实现。
一个用于实现接口的抽象类可能把接口方法安排到抽象方法上。
EXAMPLE
interface I
{
void FunctionA();
}
abstract class : I
{
public abstract void FunctionA();
}