原文地址：http://dev.firnow.com/course/4_webprogram/asp.net/netjs/2007118/85034.html
abstract class和interface是C#语言中对于抽象类定义进行支持的两种机制，正是由于这两种机制的存在，才赋予了C#强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，甚至可以相互替换，因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。

其实，两者之间还是有很大的区别的，对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。本文将对它们之间的区别进行一番剖析，试图给开发者提供一个在二者之间进行选择的依据。
下面我们主要从设计理念层面看看abstract class和interface的区别！
abstarct class在C#语言中体现了一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is a"关系，即父类和派生类在概念本质上应该是相同的。对于interface 来说则不然，并不要求interface的实现者和interface定义在概念本质上是一致的，仅仅是实现了interface定义的契约而已。为了使论述便于理解，下面将通过一个简单的实例进行说明。

考虑这样一个例子，假设在我们的问题领域中有一个关于Door的抽象概念，该Door具有执行两个动作open和close，此时我们可以通过abstract class或者interface来定义一个表示该抽象概念的类型，定义方式分别如下所示：

使用abstract class方式定义Door：
 
abstract class Door {
 abstract void open();
 abstract void close()；
}
 
使用interface方式定义Door：
 
interface Door {
 void open();
 void close();
} 

其他具体的Door类型可以extends使用abstract class方式定义的Door或者implements使用interface方式定义的Door。看起来好像使用abstract class和interface没有大的区别。

如果现在要求Door还要具有报警的功能。我们该如何设计针对该例子的类结构呢（在本例中，主要是为了展示abstract class和interface反映在设计理念上的区别，其他方面无关的问题都做了简化或者忽略）下面将罗列出可能的解决方案，并从设计理念层面对这些不同的方案进行分析。

解决方案一：

简单的在Door的定义中增加一个alarm方法，如下：

abstract class Door {
 abstract void open();
 abstract void close()；
 abstract void alarm();
}
 
 
或者
 
interface Door {
 void open();
 void close();
 void alarm();
} 

class AlarmDoor :Door {
 void open() { … }
 void close() { … }
 void alarm() { … }
}
 
 
或者
 
class AlarmDoor :Door ｛
 void open() { … }
 void close() { … }
 void alarm() { … }
｝ 

这种方法违反了面向对象设计中的一个核心原则ISP（Interface Segregation Priciple），在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变（比如：修改alarm方法的参数）而改变，反之依然。
解决方案二：

既然open、close和alarm属于两个不同的概念，根据ISP原则应该把它们分别定义在代表这两个概念的抽象类中。定义方式有：这两个概念都使用abstract class方式定义；两个概念都使用interface方式定义；一个概念使用abstract class方式定义，另一个概念使用interface方式定义。

显然，由于Java语言不支持多重继承，所以两个概念都使用abstract class方式定义是不可行的。后面两种方式都是可行的，但是对于它们的选择却反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理。我们一一来分析、说明。

如果两个概念都使用interface方式来定义，那么就反映出两个问题：

1、我们可能没有理解清楚问题领域，AlarmDoor在概念本质上到底是Door还是报警器？

2、如果我们对于问题领域的理解没有问题，比如：我们通过对于问题领域的分析发现AlarmDoor在概念本质上和Door是一致的，那么我们在实现时就没有能够正确的揭示我们的设计意图，因为在这两个概念的定义上（均使用interface方式定义）反映不出上述含义。

如果我们对于问题领域的理解是：AlarmDoor在概念本质上是Door，同时它有具有报警的功能。我们该如何来设计、实现来明确的反映出我们的意思呢？前面已经说过，abstract class在C#语言中表示一种继承关系，而继承关系在本质上是"is a"关系。所以对于Door这个概念，我们应该使用abstarct class方式来定义。另外，AlarmDoor又具有报警功能，说明它又能够完成报警概念中定义的行为，所以报警概念可以通过interface方式定义。如下所示：

abstract class Door { 

abstract void open();
 abstract void close()；
}
interface Alarm {
 void alarm();
}
class AlarmDoor extends Door implements Alarm {
 void open() { … }
 void close() { … }
    void alarm() { … }
} 

这种实现方式基本上能够明确的反映出我们对于问题领域的理解，正确的揭示我们的设计意图。其实abstract class表示的是"is a"关系，interface表示的是"like a"关系，大家在选择时可以作为一个依据，当然这是建立在对问题领域的理解上的，比如：如果我们认为AlarmDoor在概念本质上是报警器，同时又具有Door的功能，那么上述的定义方式就要反过来了。

abstract class和interface是C#语言中的两种定义抽象类的方式，它们之间有很大的相似性。但是对于它们的选择却又往往反映出对于问题领域中的概念本质的理解、对于设计意图的反映是否正确、合理，因为它们表现了概念间的不同的关系（虽然都能够实现需求的功能）。这其实也是语言的一种的惯用法，希望读者朋友能够细细体会。
 
原文地址：http://www.cnblogs.com/yangbin990/archive/2005/09/13/236235.html

参考:Abstract and Sealed Classes and Class Members (C# Programming Guide).
public abstract class A
{
    // Class members here.
}
abstract :必须被继承.

public abstract class A
{
    public abstract void DoWork(int i);
}
abstract class 里也可包含abstract 方法, 但方法就没有{}, 因为abstract 方法不可以有内容. 继承abstract class 的class 内部必须定义那些abstract 方法, 给他真正的含义.

// compile with: /target:library
public class D
{
    public virtual void DoWork(int i)
    {
        // Original implementation.
    }
}

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:儿子类看不到的方法, 也就是说不想让儿子看到的方法.

public sealed class D
{
// Class members here.
}
sealed:sealed class 不可以做base class,也就是说不可以被继承.当然也不可以和abstract 同时出现, 因为正好互相抵触.

原文地址：http://www.cnblogs.com/3stones/archive/2007/03/22/684694.html

c#中的interface abstract 与 virtual
2007-02-13 10:42

    

        

            

            
 
            
interface用来声明接口
1.只提供一些方法规约，不提供方法主体.  如:
public interface IPerson
{
    void getName();//不包含方法主体
}
2.方法不能用public abstract等修饰,无字段变量，无构造函数。
3.方法可包含参数。  如  
  public interface IPerson
  {
    void getAge(string s);
  }
            
  一个例子(例1)：
public interface IPerson
{ 
   IPerson();              //错误
   string name;            //错误
   public void getIDcard();//错误
            
   void getName();         //right
   void getAge(string s);  //right
}
            
实现interface的类
1.与继承类的格式一致，如 public class Chinese:IPerson{}
2.必须实现 interface 中的各个方法
            
   例2，继承例1
public class Chinese:IPerson
{ 
   public Chinese(){}                  //添加构造
   public void getName(){}          //实现getName()
   public void getAge(string s){} //实现getAge()
}
            
abstract声明抽象类、抽象方法
1.抽象方法所在类必须为抽象类
2.抽象类不能直接实例化，必须由其派生类实现。
3.抽象方法不包含方法主体，必须由派生类以override方式实现此方法,这点跟interface中的方法类似
            
  如
public abstract class Book
{
  public Book()
  {   
  }
            
  public abstract void getPrice();      //抽象方法，不含主体
  public virtual void getName()   //虚方法，可覆盖
  {
      Console.WriteLine("this is a test:virtual getName()");
  }
  public virtual void getContent()   //虚方法，可覆盖
  {
      Console.WriteLine("this is a test:virtual getContent()");
  }
  public void getDate()                           //一般方法，若在派生类中重写，须使用new关键字
  {
      Console.WriteLine("this is a test: void getDate()");
   }
}
            
public class JavaBook:Book
{
      public override void getPrice()   //实现抽象方法，必须实现
      {
           Console.WriteLine("this is a test:JavaBook override abstract getPrice()");
      }
      public override void getName()   //覆盖原方法，不是必须的
      {
           Console.WriteLine("this is a test:JavaBook override virtual getName()");
      }
}
            
 测试如下：
public class test
{
   public test()
   {
    JavaBook jbook=new JavaBook();
         jbook.getPrice();      //将调用JavaBook中getPrice()
         jbook.getName();       //将调用JavaBook中getName()
         jbook.getContent();    //将调用Book中getContent()
         jbook.getDate();       //将调用Book中getDate()
            
    }
   public static void Main()
   {
            
       test t=new test();
   }
}
            
virtual标记方法为虚方法
1.可在派生类中以override覆盖此方法
2.不覆盖也可由对象调用
3.无此标记的方法(也无其他标记)，重写时需用new隐藏原方法
            
abstract 与virtual : 方法重写时都使用 override 关键字
interface中的方法和abstract方法都要求实现


原文地址：http://www.cnblogs.com/Dlonghow/archive/2008/07/26/1251974.html


            
C# 参考：internal 关键字使用小结
            
     最近在忙于Silverlight 上打印功能的实现，采用Report Definition Language(RDL) （一种 SQL Server 基于报表定义规范）。大体情况是：项目中一种原有的数据格式需要转换成一种通用的数据格式，由它来生成生成各种类型的文档（PDF、BMP等）。
            
     在定义框架的控件类时，真正对internal 访问修饰符有了较深的认识和使用，特总结如下，供参考：
            
     1. internal 关键字是类型和类型成员的访问修饰符。内部成员只有在同一程序集中的文件内才是可访问的。有关程序集的更多信息，请参见组件和程序集。
            
     2. 内部访问通常用于基于组件的开发，因为它使一组组件能够以私有方式进行合作，而不必向应用程序代码的其余部分公开。
            
        例如，用于生成图形用户界面的框架可以提供“控件”类和“窗体”类，这些类通过使用具有内部访问能力的成员进行合作。由于这些成员是内部的，它们不向正在使用框架的代码公开。
            
      在定义具有内部访问能力的成员的程序集外部，引用该成员是错误的
            
       警告  尽管不能用 C# 重写 internal virtual 方法，但可以用某些语言（如使用 Ilasm.exe 的文本 Microsoft 中间语言 (MSIL) 重写它。有关 internal 和其他访问修饰符的比较请参见 可访问性级别。