c#的一些知识点

1: try_catch_fianlly语法

2：代表（delegate）
注意，这两种的输出结果是不同的，大家可以直接去运行一下，看看：
(1)形式1
using System;

namespace Wrox.ProCSharp.AdvancedCSharp
{
 delegate double DoubleOp(double x);

 class MainEntryPoint
 {
  static void Main()
  {
   /******************************************************************************
    *     *
    * 代表数组，注意和“+”的形式区别
    * Console.WriteLine("Using operations[{0}]:", i);
    ProcessAndDisplayNumber(operations[i], 2.0);
    ProcessAndDisplayNumber(operations[i], 7.94);
    ProcessAndDisplayNumber(operations[i], 1.414);
    *
    * *****************************************************************************/
   DoubleOp [] operations =
   {
    new DoubleOp(MathsOperations.MultiplyByTwo),
    new DoubleOp(MathsOperations.Square)
   };

   for (int i=0 ; i<operations.Length ; i++)
   {
    Console.WriteLine("Using operations[{0}]:", i);
    ProcessAndDisplayNumber(operations[i], 2.0);
    ProcessAndDisplayNumber(operations[i], 7.94);
    ProcessAndDisplayNumber(operations[i], 1.414);
    Console.WriteLine();
    Console.ReadLine();
   }
  }

  static void ProcessAndDisplayNumber(DoubleOp action, double value)
  {
   double result = action(value);
   Console.WriteLine("Value is {0}, result of operation is {1}", value, result);
  }
 }

 class MathsOperations
 {
  public static double MultiplyByTwo(double value)
  {
   return value*2;
  }

  public static double Square(double value)
  {
   return value*value;
  }
 }
}
(2)形式2
using System;

namespace Wrox.ProCSharp.AdvancedCSharp
{
 delegate void DoubleOp(double value);

 class MainEntryPoint
 {
  static void Main()
  {
   
   /*****************************************************************************
    *
    *
    * DoubleOp operations = new DoubleOp(MathsOperations.MultiplyByTwo);
      operations += new DoubleOp(MathsOperations.Square);
      operations+=new DoubleOp(MathsOperations.www);
    * 注意代表“+”的作用
    *
    *
    *
    * ****************************************************************************/
   DoubleOp operations = new DoubleOp(MathsOperations.MultiplyByTwo);
   operations += new DoubleOp(MathsOperations.Square);
   operations+=new DoubleOp(MathsOperations.www);

   ProcessAndDisplayNumber(operations, 2.0);
   ProcessAndDisplayNumber(operations, 7.94);
   ProcessAndDisplayNumber(operations, 1.414);
   Console.WriteLine();
   Console.ReadLine();
  }

  static void ProcessAndDisplayNumber(DoubleOp action, double value)
  {
   Console.WriteLine("/nProcessAndDisplayNumber called with value = " + value);
   action(value);
   
  }
 }

 class MathsOperations
 {
  public static void MultiplyByTwo(double value)
  {
   double result = value*2;
   Console.WriteLine("Multiplying by 2: {0} gives {1}", value, result);
  }

  public static void Square(double value)
  {
   double result = value*value;
   Console.WriteLine("Squaring: {0} gives {1}", value, result);
  }
  public static void www(double value)
  {
   Console.WriteLine("ddddddddddddd");
  }
  
 }
}
３：Ｓtring与StringBuilder对比

４：关键字ref
using System;

namespace Wrox.ProCSharp.Basics
{
 class ParameterTest
 {
  /* ************************************************
   *
   * 关键字ref,表示引用！
   *
   * ************************************************/
  static void SomeFunction(int[] ints, ref int i)
  {
   ints[0] = 100;
   i = 100;
  }
  
  public static int Main()
  {
   int i = 0;
   int[] ints = { 0, 1, 2, 4, 8 };

   // Display the original values
   Console.WriteLine("i = " + i);
   Console.WriteLine("ints[0] = " + ints[0]);
   Console.WriteLine("Calling SomeFunction...");
   // After this method returns, ints will be changed,
   // but i will not
   SomeFunction(ints, ref i);
   Console.WriteLine("i = " + i);
   Console.WriteLine("ints[0] = " + ints[0]);
   
   Console.ReadLine();
   return 0;
  }
 }
}
5：命名空间
using System;

namespace Wrox.ProCSharp.Basics
{
 class Client
 {
  public static void Main()
  {
   MathLib mathObj = new MathLib();
   Console.WriteLine(mathObj.Add(7,8));
   Console.ReadLine();
  }
 }
}
/****************************************************************
 *
 * 定义相同的命名空间
 *
 * ****************************************************************/
namespace Wrox.ProCSharp.Basics
{
 public class MathLib
 {
  public int Add(int x, int y)
  {
   return x + y;
  }
 }
}
6：不规则数组的声明和使用
using System;

namespace Wrox.ProCSharp.Basics
{
    class MainEntryPoint
    {
        static void Main()
        {
            // Declare a two-dimension jagged array of authors' names
            /************************************************************************
             *
             *
             * 非规则数组的声明和定义
             *  string[][] novelists = new string[3][];
    
                novelists[0] = new string[] {"Fyodor", "Mikhailovich", "Dostoyevsky"};
    
                novelists[1] = new string[] {"James", "Augustine", "Aloysius", "Joyce"};
    
                novelists[2] = new string[] {"Miguel", "de Cervantes", "Saavedra"};
             * **********************************************************************
             *
             *
             *
             * C# Copy Codepublic int GetLength ( int dimension）

               C++ Copy Codepublic:int GetLength ( int dimension)
             *
             * 得到第一维的长度
             *
             *
             * **********************************************************************/
            string[][] novelists = new string[3][];

            novelists[0] = new string[] { "Fyodor", "Mikhailovich", "Dostoyevsky" };

            novelists[1] = new string[] { "James", "Augustine", "Aloysius", "Joyce" };

            novelists[2] = new string[] { "Miguel", "de Cervantes", "Saavedra" };

            // Loop through each novelist in the array
            int i;

            for (i = 0; i < novelists.GetLength(0); i++)
            {
                // Loop through each name for the novelist
                int j;
                for (j = 0; j < novelists[i].GetLength(0); j++)
                {
                    // Display current part of name
                    Console.Write(novelists[i][j] + " ");
                }

                // Start a new line for the next novelist
                Console.Write("/n");
            }

            Console.ReadLine();
        }
    }
}
7：格式输出
/* * *****************************************************************
 *
 *
  * 字符 说明 示例 输出
  C 或c
  货币
  Console.Write("{0:C}", 2.5);

  Console.Write("{0:C}", -2.5);
  $2.50

  ($2.50)
  
  D 或d
  十进制数
  Console.Write("{0:D5}", 25);
  00025
  
  E 或e
  科学型
  Console.Write("{0:E}", 250000);
  2.500000E+005
  
  F 或f
  固定点
  Console.Write("{0:F2}", 25);

  Console.Write("{0:F0}", 25);
  25.00

  25
  
  G 或g
  常规
  Console.Write("{0:G}", 2.5);
  2.5
  
  N 或n
  数字
  Console.Write("{0:N}", 2500000);
  2,500,000.00
  
  X 或x
  十六进制
  Console.Write("{0:X}", 250);

  Console.Write("{0:X}", 0xffff);
  FA

  FFFF
  *
 * *****************************************************************/
using System;

namespace Wrox.ProCSharp.Basics
{
 class MyFirstCSharpClass
 {
  static void Main()
  {
   Console.WriteLine("This isn't at all like Java!");
   double d = 0.234;
            int i=666;
   Console.WriteLine("{0:C}", d);
            Console.WriteLine("{0:E}", d);
            Console.WriteLine("{0:X}", i);
         Console.ReadLine();
  }
 }
}
9: 镶套结构体的定义
using System;

namespace ConsoleApplication1
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //结构体也可以直接定义
            student stu;
            stu._age=22;
            stu._name="mqt";
       //小数默认是double 类型，要使用float 类型，必须在后面加f，另外一种是decimal 类型，必须加Ｍ
            stu._weight=130.4f;
            stu._address._city="shanghai";
            stu._address._room="414";
            Console.WriteLine(stu._address._city);

   //结构体new 出来
   student stu1=new student();
   stu1._address._city="shandongwucheng";
   Console.WriteLine(stu1._address._city);
   Console.ReadLine();
  
  }
 }
     //结构体的定义
 public struct student
 {
  public string _name;
  public int _age;
  public float _weight;
   //镶套结构体
   public struct address
   {
    public string _room;
    public string _city;
   }
  //镶套结构体的定义

  public address _address;
 }
 }
10 关键字typeof ,as ,is 的应用,并且验证多态性
using System;

namespace typeof_is_as
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //类型版别typeof();
   int i;
   Console.WriteLine(typeof(int));
   Console.WriteLine(typeof(man));
   //对镶套类的类型判断应该这样student_man.people
   Console.WriteLine(typeof(student_man.people));
   
   //is操作符号，返回false or true
   student_man st_man=new student_man();
   Console.WriteLine("student_man is a man?::{0}",st_man is man);
   Console.WriteLine("student_man is a man?::{0}",st_man is student_man);
   Console.WriteLine("student_man is a man?::{0}",st_man is man);
   
   //as操作符号，返回类型
   man man1=st_man as man;
   man1.output();
          man1.output1();
   Console.ReadLine();
   
  }
 }
 
 class man
 {
  private  string high;
  virtual public void output()
  {
            high = "你好，这里是华东师范大学计算机系，欢迎访问我的Ｂｌｏｇ";
   Console.WriteLine(high);
  }

        public void output1()
        {
            high = "呵呵，我是在基类中：因为基类中是非虚拟函数，所以这里不是多态";
            Console.WriteLine(high);
        }

 }
 
 class student_man:man
 {
  private int age;
  private string major;
  public class people
  {
   private string name;
  }
   override public void output()
  {
   Console.WriteLine("呵呵，我是在派生类中的：这是由于多态的作用，动态邦定了");
  }
  
         public void output1()
        {

            Console.WriteLine("验证多态性，看是不是应用了大态");
        }
           
 }
}

11：装箱与拆箱
using System;
//********************************************************
/*装箱过程其过程相当于有一个中间类Int_Box
 * class Int_Box
 * {
 *  public int value;
 *  public Int_Box(int t)
 *  {
 *   value=t;
 *  }
 *  public override string ToString()
 *  {
 *   return value.ToString();
 *  }
 * }
 * Int_Box temp=new Int_Box(10);
 * Object obj=temp;
 * *******************************************************/

namespace Box_UnBox
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   //装箱过程
   int i=10;
   object obj=i;
   i=20;
   Console.WriteLine("int:i={0}",i);
   Console.WriteLine("object:obj={0}",obj.ToString());
   
   //拆箱过程
   int j=(int)obj;
   Console.WriteLine("int : j={0}",j);
   Console.WriteLine("object:obj={0}" ,obj.ToString());   

   j=20;
   Console.WriteLine("int : j={0}",j);
   Console.WriteLine("object:obj={0}",obj.ToString() );

   Console.ReadLine();
   //
   // TODO: 在此处添加代码以启动应用程序
   //
  }
 }
}
12：操作的重载
using System;

namespace overwrite_operator
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   Complex com=new Complex(10,10);
   com.Output();
   
   com++;
   com.Output();

   Complex com2=new Complex(20,20);
   
   Complex com3=new Complex(0,0);
   com3=com2+com;
   com3.Output();
   Console.ReadLine();   
   //
   // TODO: 在此处添加代码以启动应用程序
   //
  }
 }
 class Complex
 {
  //字段
  private float _real;
  private float _img;
  //构造函数
  public Complex(float real,float img)
  {
   _real=real;
   _img=img;
  }
  //属性 
  public float real_value
  {
   get
   {
    return _real;
   }
   set
   {
    _real=value;
   }
  }
  //属性
  public float img_value
  {
   get
   {
    return _img;
   }
   {
    _img=value;
   set
   }
  }
  //一元操作符的重载
  public static Complex operator +(Complex com1,Complex com2)
  {
   Complex com=new Complex(0,0);
   com.img_value=com1.img_value+com2.real_value;
   com.real_value=com1.real_value+com2.real_value;
   return com;
  }
  //二元操作符的重载
  public static Complex operator++(Complex com1)
  {
   Complex com=new Complex(0,0);
   com.real_value=com1.real_value+1;
   com.img_value=com1.img_value+1;
   return com;
  }

  public void Output()
  {
   Console.WriteLine(real_value.ToString()+"+"+img_value.ToString()+"i");
  }
    
 }
}
13：索引函数（this[]）和属性函数( set/get)
using System;

namespace index
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   
   person per1=new person("mqt2003");
   per1["phone_number"]="13482451786";
   per1["fax_number"]="6212632";
   per1.Output();
   Console.ReadLine();
   
  }
 }
 //一string 为索引的类
 public class person
 {
  private string phone_number;
  private string fax_number;
  private string name;
  
  public person()
  {
  }
  public person(string name1)
  {
   this.name=name1;
  }

  public string person_name
  {
   get
   {
    return name;
   }
   set
   {
    name=value;
   }
  }
  
  //索引函数，以this 为关键字，其中使用get /和set关键字，相当于属性的扩充
  public string this[string type]
  {
   set
   {
    string up=type.ToLower();
    switch(up)
    {
     case "phone_number":
      phone_number=value;
      break;
     case "fax_number":
      fax_number=value;
      break;
     default:
      break;
    }
   }
   get
   {
    string up=type.ToLower();
    switch(up)
    {
     case "phone_number":
      return phone_number;
     case "fax_number":
      return fax_number;
     default:
      return null;
    }
   }
  }
  public void Output()
  {
   Console.WriteLine("the person's name is  {0}",name);
   Console.WriteLine("his phone number is  {0}",phone_number);
   Console.WriteLine("his fax_number is {0}", fax_number);
  }
 }
}
14:事件（Event）
此事件符合.NET的C#事件格式
using System;

namespace Events
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {   
   long speed;
   speed=long.Parse(Console.ReadLine());
   CheckSpeed check=new CheckSpeed();
   DoSomething something=new DoSomething();
 //将响应事件函数和激发事件函数绑定，只要一激发事件，就通过代表调用响应事件函数
   check.myEvent+=new self_delegate(something.SlowDown);
   check.CheckLimit(speed);
   Console.ReadLine();

  }
 } 
 
//自己定义的,派生自EventArgs
 public class self_event:EventArgs
 {
  //类的字段
  private long speed;

  public self_event(long speed)
  {
   this.speed=speed;
  }
  //类的属性
  public long get_speed
  {
   get
   {  
    return speed ;
   }
  }

  public string WarningMessage
  {
   get
   {
    return("Warning");
   }
  }
 }
 public class CheckSpeed
 {
  //通过关键字event,声明一个myEvent，并且将其和自定义代表绑定
  public event self_delegate myEvent;
  //定义激发事件函数，并且符合.NET标准，即参数为（object, eventArgs)
  public void CheckLimit(long speed)
  {
   if(speed>60)
   {
    self_event speed_self_event=new self_event(speed);
    myEvent(this,speed_self_event);//激发事件
   }
   else
   {
    Console.WriteLine("OK");
   }
  } 
 }
  //定义一个代表
 
public delegate void self_delegate(object sender,self_event e);
  //响应事件函数，通过代表对激发的事件做出响应
 
public class DoSomething
 {
  public void SlowDown(object sender,self_event e)
  {
   Console.WriteLine(" wrong,warning!!!!");
  }
 }
}
15：文件读取和写入

16:规则和不规则数组的定义和使用
using System;

namespace mqt
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   
   //规则的二维数组
   string [,] str=new string[3,4];
   for(int i=0;i<3;i++)
   {
    for(int j=0;j<4;j++)
     str[i,j]="aaaa"+i.ToString()+j.ToString();
   }
   for(int i=0;i<3;i++)
   {
    for(int j=0;j<4;j++)
     Console.WriteLine(str[i,j]);
   }
   
   //不规则的二维数组
   string [][] str2=new string[3][];
   for(int i=0;i<3;i++)
   {
    str2[i]=new string [i+3];
   }
   for(int i=0;i<3;i++)
    for(int j=0;j<str2[i].Length;j++)
     str2[i][j]="ddddddddddd"+i.ToString()+j.ToString();
   for(int i=0;i<3;i++)
    for(int j=0;j<str2[i].Length;j++)
     Console.WriteLine(str2[i][j]);
   Console.ReadLine();
 }
 }
}
17：哈希表的使用
using System;
using System.Text;

/*********************************************
 * 集和命名空间
 ********************************************/

using System.Collections;

namespace Wrox.ProCSharp.SocialSecurityNumbers
{
 class MainEntryPoint
 {
  static void Main()
  {
   TestHarness harness = new TestHarness();
   harness.Run();
  }
 }

 class TestHarness
 {
  /***************************************************************
   *
   * 哈希表
   *
   * *************************************************************/

  Hashtable employees = new Hashtable(31);

  public void Run()
  {
   EmployeeID idMortimer = new EmployeeID("B001");
   EmployeeData mortimer = new EmployeeData(idMortimer, "Mortimer", 100000.00M);
   EmployeeID idArabel = new EmployeeID("W234");
   EmployeeData arabel= new EmployeeData(idArabel, "Arabel Jones", 10000.00M);

   employees.Add(idMortimer, mortimer);
   employees.Add(idArabel, arabel);

   while (true)
   {
    try
    {
     Console.Write("Enter employee ID (format:A999, X to exit)> ");
     string userInput = Console.ReadLine();
     userInput = userInput.ToUpper();
     if (userInput == "X")
      return;
     EmployeeID id = new EmployeeID(userInput);
     DisplayData(id);
    }
    catch (Exception e)
    {
 Console.WriteLine("Exception occurred. Did you use the correct format for the employee ID?");
     Console.WriteLine(e.Message);
     Console.WriteLine();
    }
    Console.WriteLine();
   }
  }
  private void DisplayData(EmployeeID id)
  {
   object empobj = employees[id];
   if (empobj != null)
   {
    EmployeeData employee = (EmployeeData)empobj;
    Console.WriteLine("Employee: " + employee.ToString());
   }
   else
    Console.WriteLine("Employee not found: ID = " + id);
  }
 }

 class EmployeeData
 {
  private string name;
  private decimal salary;
  private EmployeeID id;

  public EmployeeData(EmployeeID id, string name, decimal salary)
  {
   this.id = id;
   this.name = name;
   this.salary = salary;
  }
  
  /**********************************************************
   *
   * StringBuilder的命名空间是System.Text
   *
   * 其中还显示了字符的输出格式如{0:C} 或者 {0,-20}
   *
   * *********************************************************/
  public override string ToString()
  {
   StringBuilder sb = new StringBuilder(id.ToString(), 100);
   sb.Append(": ");
   sb.Append(string.Format("{0,-20}", name));
   sb.Append(" ");
   sb.Append(string.Format("{0:C}", salary));
   return sb.ToString();
  }
 }

 class EmployeeID
 {
  private readonly char prefix;
  private readonly int number;
  

  public EmployeeID(string id)
  {
   prefix = (id.ToUpper())[0];
   number = int.Parse(id.Substring(1,3));
  }
  public override string ToString()
  {
   return prefix.ToString() + string.Format("{0,9:000}", number);
  }
  
  /**************************************************************
   *
   * 用作 Hashtable 中的键的对象必须实现或继承 Object.GetHashCode 和 Object.Equals 方法。
   *
   *
   * ************************************************************/
  public override int GetHashCode()
  {
   string str = this.ToString();
   return str.GetHashCode();
  }

  public override bool Equals(object obj)
  {
   EmployeeID rhs = obj as EmployeeID;
   if (rhs == null)
    return false;
   if (prefix == rhs.prefix && number == rhs.number)
    return true;
   return false;
  }
 }
}
18：IDisposable接口

using System;
using System.IO;

namespace Wrox.ProCSharp.AdvancedCSharp
{
 class MainEntryPoint
 {
  static void Main()
  {
   string fileName;
   Console.Write("Please type in the name of the file " +
    "containing the names of the people to be cold-called > ");
   fileName = Console.ReadLine();
   ColdCallFileReader peopleToRing = new ColdCallFileReader();

   try
   {
    peopleToRing.Open(fileName);
    for (int i=0 ; i<peopleToRing.NPeopleToRing; i++)
    {
     peopleToRing.ProcessNextPerson();
    }
    Console.WriteLine("All callees processed correctly");
   }
   catch(FileNotFoundException e)
   {
    Console.WriteLine("The file {0} does not exist", fileName);
   }
   catch(ColdCallFileFormatException e)
   {
    Console.WriteLine(
     "The file {0} appears to have been corrupted", fileName);
    Console.WriteLine("Details of problem are: {0}", e.Message);
    if (e.InnerException != null)
     Console.WriteLine(
      "Inner exception was: {0}", e.InnerException.Message);
   }
   catch(Exception e)
   {
    Console.WriteLine("Exception occurred:/n" + e.Message);
   }        
   finally
   {
    peopleToRing.Dispose();
   }
   Console.ReadLine();
  }
 }
 /*****************************************************************************************
  *
  *
  *class ColdCallFileReader :IDisposable
  * .NET Framework 类库  

   IDisposable 接口
   定义一种释放分配的非托管资源的方法。

   有关此类型所有成员的列表，请参阅 IDisposable 成员。

   [Visual Basic]
   Public Interface IDisposable
   [C#]
   public interface IDisposable
   [C++]
   public __gc __interface IDisposable
   [JScript]
   public interface IDisposable

  *
  * 备注
使用此方法关闭或释放由实现此接口的类的实例保持的文件、流和句柄等非托管资源。根据约定，此方法用于与释放对象保持的资源或准备对象以便重新
使用有关的所有任务。

实现此方法时，对象必须通过在包容层次结构中传播调用来进行查找，以确保释放所有保持的资源。例如，如果对象 A 分配对象 B，而对象 B 又分配对象
 C，那么 A 的 Dispose 实现必须对 B 调用 Dispose，而 B 反过来对 C 调用 Dispose。如果对象的基类实现了 IDisposable，对象还必须调用它们基类的
  Dispose 方法。

如果某对象的 Dispose 方法被调用一次以上，则该对象必须忽略第一次调用后的所有调用。如果对象的 Dispose 方法被调用多次，对象不得引发异常。
如果由于资源已被释放且以前未调用 Dispose 而发生错误时，Dispose 会引发异常。

资源类型可能使用特定的约定来表示已分配状态和已释放状态。流类即是这样一种示例，传统上认为它们要么打开要么关闭。具有此类约定的类可能选
择实现带有自定义名称（如 Close）的公共方法，由该方法调用 Dispose 方法。
  *
 
  *
  *
 ********************************************************************************************/

 class ColdCallFileReader :IDisposable
 {
  FileStream fs;
  StreamReader sr;
  uint nPeopleToRing;
  bool isDisposed = false;
  bool isOpen = false;

  public void Open(string fileName)
  {
   if (isDisposed)
    throw new ObjectDisposedException("peopleToRing");
   fs = new FileStream(fileName, FileMode.Open);
   sr = new StreamReader(fs);
   try
   {
    string firstLine = sr.ReadLine();
    nPeopleToRing = uint.Parse(firstLine);
    isOpen = true;
   }
   catch (FormatException e)
   {
    throw new ColdCallFileFormatException("First line isn/'t an integer", e);
   }
  }

  public uint NPeopleToRing
  {
   get
   {
    if (isDisposed)
     throw new ObjectDisposedException("peopleToRing");
    if (!isOpen)
     throw new UnexpectedException(
      "Attempt to access cold call file that is not open");
    return nPeopleToRing;
   }
  }

  public void Dispose()
  {
   if (isDisposed)
    return;

   isDisposed = true;
   isOpen = false;
   if (fs != null)
   {
    fs.Close();
    fs = null;
   }
  }

  public void ProcessNextPerson()
  {
   if (isDisposed)
    throw new ObjectDisposedException("peopleToRing");
   if (!isOpen)
    throw new UnexpectedException(
     "Attempt to access cold call file that is not open");
   try
   {
    string name;
    name = sr.ReadLine();
    if (name == null)
     throw new ColdCallFileFormatException("Not enough names");
    if (name[0] == 'Z')
    {
     throw new LandLineSpyFoundException(name);
    }
    Console.WriteLine(name);
   }
   catch(LandLineSpyFoundException e)
   {
    Console.WriteLine(e.Message);
   }

   finally
   {
   }
  }
 }

 /*************************************************************************************
  *
  *
  * 自己建立的异常类
  *
  ****************************************************************************************/

 class LandLineSpyFoundException : ApplicationException
 {
  public LandLineSpyFoundException(string spyName)
   :   base("LandLine spy found, with name " + spyName)
  {
  }

  public LandLineSpyFoundException(string spyName, Exception innerException)
   :   base("LandLine spy found, with name " + spyName, innerException)
  {
  }
 }

 class ColdCallFileFormatException : ApplicationException
 {
  public ColdCallFileFormatException(string message)
   :   base(message)
  {
  }

  public ColdCallFileFormatException(string message, Exception innerException)
   :   base(message, innerException)
  {
  }
 }

 class UnexpectedException : ApplicationException
 {
  public UnexpectedException(string message)
   :   base(message)
  {
  }

  public UnexpectedException(string message, Exception innerException)
   :   base(message, innerException)
  {
  }
 }
}