定义自己的异常类

  • 设计自己的异常不仅繁琐，还容易出错。主要原因是从Exception派生的所有类型都应该是可序列化的（serializable），使它们能穿越AppDomain边界或者写入日志/数据库。

写一个自己的泛型Exception<TExceptionArgs>类，它像下面这样定义

  1. [Serializable]
  2. public sealed class Exception<TExceptionArgs> : Exception, ISerializable
  3.     where TExceptionArgs : ExceptionArgs
  4. {
  6.     private const String c_args = "Args";  // For (de)serialization
  7.     private readonly TExceptionArgs m_args;
  9.     public  TExceptionArgs Args
  10.     {
  11.         get
  12.         {
  13.             return m_args;
  14.         }
  15.     }
  17.     public Exception(String message = null, Exception innerException = null)
  18.         : this(null, message, innerException) { }
  20.     public Exception(TExceptionArgs args, String message = null,
  21.                      Exception innerException = null): base(message, innerException)
  22.     {
  23.         m_args = args;
  24.     }
  26.     // This constructor is for deserialization; since the class is sealed, the constructor is
  27.     // private. If this class were not sealed, this constructor should be protected
  28.     [SecurityPermission(SecurityAction.LinkDemand,
  29.                         Flags = SecurityPermissionFlag.SerializationFormatter)]
  30.     private Exception(SerializationInfo info, StreamingContext context)
  31.         : base(info, context)
  32.     {
  33.         m_args = (TExceptionArgs)info.GetValue(c_args, typeof(TExceptionArgs));
  34.     }
  36.     // This method is for serialization; it’s public because of the ISerializable interface
  37.     [SecurityPermission(SecurityAction.LinkDemand,
  38.                         Flags = SecurityPermissionFlag.SerializationFormatter)]
  39.     public override void GetObjectData(SerializationInfo info, StreamingContext context)
  40.     {
  41.         info.AddValue(c_args, m_args);
  42.         base.GetObjectData(info, context);
  43.     }
  44.     public override String Message
  45.     {
  46.         get
  47.         {
  48.             String baseMsg = base.Message;
  49.             return (m_args == null) ? baseMsg : baseMsg + " (" + m_args.Message + ")";
  50.         }
  51.     }
  53.     public override Boolean Equals(Object obj)
  54.     {
  55.         Exception<TExceptionArgs> other = obj as Exception<TExceptionArgs>;
  56.         if (other == null) return false;
  57.         return Object.Equals(m_args, other.m_args) && base.Equals(obj);
  58.     }
  59.     public override int GetHashCode()
  60.     {
  61.         return base.GetHashCode();
  62.     }
  63. }

TExceptionArgs约束为的ExceptionArgs基类非常简单，它看起来像下面这样

  1. [Serializable]
  2. public abstract class ExceptionArgs {
  3.    public virtual String Message { get { return String.Empty; } }
  4. }

要定义代表磁盘满的异常类，可以像下面这样

  1. [Serializable] 
  2. public sealed class DiskFullExceptionArgs : ExceptionArgs { 
  3.    private readonly String m_diskpath; // private field set at construction time 
  5.    public DiskFullExceptionArgs(String diskpath) { m_diskpath = diskpath; } 
  7.    // Public read­only property that returns the field  
  8.    public String DiskPath { get { return m_diskpath; } }  
  10.    // Override the Message property to include our field (if set) 
  11.    public override String Message { 
  12.       get {  
  13.          return (m_diskpath == null) ? base.Message : "DiskPath=" + m_diskpath; 
  14.       } 
  15.    } 
  16. }

现在，可以像下面这样写来抛出并捕捉这样的一个异常

  1. public static void TestException() {  
  2.    try {  
  3.       throw new Exception<DiskFullExceptionArgs>( 
  4.          new DiskFullExceptionArgs(@"C:\"), "The disk is full"); 
  5.    } 
  6.    catch (Exception<DiskFullExceptionArgs> e) { 
  7.       Console.WriteLine(e.Message); 
  8.    } 
  9. }