using System;
namespace ConsoleApplication8 
{ 
　　class Program 
　　{ 
　　　　static void Main(string[] args) 
　　　　{ 
　　　　　　BClass b = new BClass(); 
　　　　　　b.m1(); 
　　　　} 
　　} 
　　abstract class AClass 
　　{ 
　　　　　　public abstract void m1(); 
　　　　　　public abstract void m2(); 
　　} 
　　class BClass : AClass 
　　{ 
　　　　public override void m1() 
　　　　{ 
　　　　　　throw new NotImplementedException(); 
　　　　} 
　　　　//public override void m2() 
　　　　//{ 
　　　　　　// throw new NotImplementedException(); 
　　　　//} 
　　} 
}

public abstract void MyMethod();

interface I 
{ 
void M(); 
} 
abstract class C: I 
{ 
public abstract void M(); 
} 
抽象类实例: 
// abstract_keyword.cs 
// 抽象类 
using System; 
abstract class BaseClass // 抽象类 
{ 
protected int _x = 100; //抽象类可以定义字段,但不可以是抽象字段,也没有这一说法. 
protected int _y = 150; 
public BaseClass(int i) //可以定义实例构造函数,仅供派生的非抽象类调用; 这里显式提供构造函数,编译器将不再提供默认构造函数. 
{ 
fielda = i; 
} 
public BaseClass() 
{ 
} 
private int fielda; 
public static int fieldsa = 0; 
public abstract void AbstractMethod(); // 抽象方法 
public abstract int X { get; } //抽象属性 
public abstract int Y { get; } 
public abstract string IdxString { get; set; } //抽象属性 
public abstract char this[int i] { get; } //抽象索引器 
}
class DerivedClass : BaseClass 
{ 
private string idxstring; 
private int fieldb; 
//如果基类中没有定义无参构造函数,但存在有参数的构造函数, 
//那么这里派生类得构造函数必须调用基类的有参数构造函数,否则编译出错 
public DerivedClass(int p) 
: base(p) //这里的:base(p)可省略,因为基类定义了默认的无参构造函数 
{ 
fieldb = p; 
} 
public override string IdxString //覆盖重新属性 
{ 
get
{ 
return idxstring; 
} 
set
{ 
idxstring = value; 
} 
} 
public override char this[int i] //覆盖重写索引器 
{ 
get { return IdxString[i]; } 
} 
public override void AbstractMethod() 
{ 
_x++; 
_y++; 
}
public override int X // 覆盖重写属性
{
 get
 {
  return _x + 10;
 }
}
 
public override int Y // 覆盖重写属性
{
 get
 {
  return _y + 10;
 }
}
 
static void Main()
{
 DerivedClass o = new DerivedClass(1);
 o.AbstractMethod();
 Console.WriteLine("x = {0}, y = {1}", o.X, o.Y);
}
}