• C#自定义异常

    2007-06-18 17:25:00
    不过处理这些错误的异常,.Net已经都帮我们写好了.但是如果一个字符串输入你想判断他是不是二进制数..这种异常你会怎么处理呢,,返回一个错误标识吗?如果你写的函数是二进制转换成十进制,返回的值是整型.这个错误...
     
    在写方法时,是否遇见数据输入的错误呢.如果字符串格式不能转换成整型的什么.不过处理这些错误的异常,.Net已经都帮我们写好了.
    但是如果一个字符串输入你想判断他是不是二进制数..这种异常你会怎么处理呢,,返回一个错误标识吗?如果你写的函数是二进制转换成十进制
    ,返回的值是整型.这个错误返回值如果标识呢...哈哈,,,你可能会说出几种或几十种解决方法.....

    下面就是我通过异常来解决的一个方法哦...
    如果你想看我的处理方法,,或想了解下如何自定义一个自己异常提示..那就继续往下吧...

    创建自定义异常主要可以两个类中派生而来:
    1.ApplicationException 类
    2.System.Exception类
    上面两个类具体要怎么用,,还得待考察哦..
     
     
    今天我是用System.Exception这个类来派生我的自己类哦.
    代码:
    1. 创建自定义异常类
     public class UserDefinedException : System.Exception // 看到没继承System.Exception类
     {
      private string message;// 错误消息
      // 下面是构造函数..你可自己多写几个..把他变成多态可能会更灵活哦.
      public UserDefinedException(string Message) : base() // 这边是重写构造函数
      {
       message = Message;
       //
       // TODO: 在此处添加构造函数逻辑
       //
      }
      /// <summary>
      /// 重写异常错误信息
      /// </summary>
      /// <returns></returns>
      public override string ToString() // 重写ToString方法,请看下面override说明
      {
       return message;
      }
     }
     
    override说明:(MSDN里写的哦)
    使用 override 修饰符来修改方法、属性、索引器或事件。重写方法提供从基类继承的成员的新实现。由重写声明重写的方法称为重写基方法
    。重写基方法必须与重写方法具有相同的签名。不能重写非虚方法或静态方法。重写基方法必须是虚拟的、抽象的或重写的。重写声明不能更
    改虚方法的可访问性。重写方法和虚方法必须具有相同的访问级修饰符。不能使用下列修饰符修改重写方法:new   static    virtual  
    abstract重写属性声明必须指定与继承属性完全相同的访问修饰符、类型和名称,并且重写属性必须是虚拟的、抽象的或重写的。
     
    2. 自定义异常的使用:
      public static int BinarySystemToAlgorism(string BinarySystemValue)
      {
       BinarySystemValue = BinarySystemValue.Trim();
       int Algorism = 0;
       int len = BinarySystemValue.Length;
       int temp;
       int tempPow = 0;
       int col = 0;
       for(int index = len - 1;index > -1;index --)
       {
         temp = Convert.ToInt32(BinarySystemValue[col].ToString());
         if(!(temp == 0 || temp == 1))
         {
          // 看到没在这边哦,由于我的写在不同一个项目所以带上的命名空间哦.
          throw new FarSeekClass.UserDefinedException("出错了,二进制输入出错!");
         }
         col += 1;
         tempPow = Pow(2,index);
         Algorism += temp * tempPow;
        
       }
       return Algorism;
      }
     
    3.  外面接收异常消息:
       try
       {
        this.TextBox1.Text = FarSeekClass.DataSwitch.BinarySystemToAlgorism(TH.Text).ToString();
       }
       catch(FarSeekClass.UserDefinedException ex) // 注意这边,catch后面异常类是写了我们自己定义的类名
       {
        Response.Write(ex.ToString());
       }
     
    以上就是我今晚最的价值的.
    嘻....多给我提意见哦..记得给留言,,路过也留个影哦..
     
    展开全文
  • C# 自定义异常类型

     

    ExceptionArgs.cs:

    泛型的异常类:

    注:C#只允许自定义的类继承自系统异常类的基类:System.Exception,并且继承自System.Exception类的所有异常类型,都必须是可被序列化的,这使得这些异常信息得以穿越AppDomain(比如Remoting服务端异常有可能需要返回到远程调用方,这时就不得不穿越AppDomain)或者写入日志/数据库等。

     

    定义一个磁盘满的异常类:

     

    如果没有额外的数据要包含到类中,可以简单地写:

     

    抛出/捕获自定义异常:

     

     

     

    展开全文
  • C# 自定义异常的总结

    2011-10-08 10:38:42
    C#中所有的异常类型都继承自System.Exception,也就是说,System.Exception是所有异常类的基类. 总起来说,其派生类分为两种:  1. SystemException类: 所有的CLR提供的异常类型都是由SystemException派生。

        在C#中所有的异常类型都继承自System.Exception,也就是说,System.Exception是所有异常类的基类. 总起来说,其派生类分为两种:
       1. SystemException类: 所有的CLR提供的异常类型都是由SystemException派生。
       2. ApplicationException类: 由用户程序引发,用于派生自定义的异常类型,一般不直接进行实例化。

       创建自定义异常类应严格遵循几个原则
    1. 声明可序列化(用于进行系列化,当然如果你不需要序列化。那么可以不声明为可序列化的)
    2. 添加一个默认的构造函数
    3. 添加包含message的构造函数
    4. 添加一个包含message,及内部异常类型参数的构造函数
    5. 添加一个序列化信息相关参数的构造函数.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.IO;
    using System.Runtime.Serialization.Formatters.Binary;
    namespace ConsoleApplication3
    {
        [Serializable] //声明为可序列化的 因为要写入文件中
        public class PayOverflowException : ApplicationException//由用户程序引发,用于派生自定义的异常类型
        {
            /// <summary>
            /// 默认构造函数
            /// </summary>
            public PayOverflowException() { }
            public PayOverflowException(string message)
                : base(message) { }
            public PayOverflowException(string message, Exception inner)
                : base(message, inner) { }
            //public PayOverflowException(System.Runtime.Serialization.SerializationInfo info,
            //    System.Runtime.Serialization.StreamingContext context)
            //    : base(info, context) { }
        }
    
        internal class Employee
        {
            public int ID { get; set; }
            public string Name { get; set; }
            /// <summary>
            /// current pay
            /// </summary>
            public int CurrPay { get; set; }
    
            public Employee() { }
            public Employee(int id, string name, int currpay)
            {
                this.ID = id;
                this.Name = name;
                this.CurrPay = currpay;
            }
    
            /// <summary>
            /// 定义一个GiveBunus的虚方法以供不同的派生类进行重载
            /// </summary>
            /// <param name="amount">奖金额度</param>
            public virtual void GiveBunus(int amount)
            {
                //用一个临时变量记录递增之前的值
                var pay = CurrPay;
    
                this.CurrPay += amount;
    
                if (CurrPay > 10000)
                {
                    //发生异常,将CurrPay的值进行恢复,
                    //并抛出异常,外部程序捕获次异常
                    this.CurrPay = pay;
                    var ex = new PayOverflowException("The employee's max pay should be no more than 10000.");
                    throw ex;
                }
            }
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                Console.WriteLine("**** 创建Employee对象,并用try/catch捕获异常 *****");
    
                var emp = new Employee(10001, "Yilly", 8000);
                try
                {
                    emp.GiveBunus(3000);
                }
                catch (PayOverflowException ex)
                {
                    Console.WriteLine("异常信息:{0}\n发生于{1}类的{2}方法", ex.Message,
                        ex.TargetSite.DeclaringType, ex.TargetSite.Name);
    
                    try
                    {
                        var file = new FileStream(@"c:\customerexception.txt", FileMode.Create);
                        //*** 异常信息写入文件中的代码省略...
                        //以序列化方式写入
                        BinaryFormatter bf = new BinaryFormatter();
                        bf.Serialize(file, ex);
                        file.Close();
    
                        //以字节方式写入
                        //byte[] buffer = System.Text.Encoding.Default.GetBytes(ex.Message);
                        //int leng = 0;
                        //leng = buffer.GetLength(0);
                        //file.Write(buffer, 0, leng);
                        //file.Close();
                    }
                    catch (Exception ex1)
                    {
                        var inner = new PayOverflowException(ex.Message, ex1);
                        throw inner;
                    }
                }
    
            }
        }
    }
    

     值得注意的是:在实例化的时候调用的是PayOverflowException(string message, Exception inner)构造函数,
     如果本程序如果有其他程序在调用的时候, 可以通过.InnerExcetpion的Message属性进行查看内部异常。

    展开全文
  • C#自定义异常

    2014-10-22 19:14:43
    using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace ConsoleApplication1 { class MyException:ApplicationException
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace ConsoleApplication1
    {
        class MyException:ApplicationException
        {
            public MyException(string msg) : base(msg) { }
        }
        class Program
        {
            static void Main(string[] args)
            {
                try{
                    string t = Console.ReadLine();
                    char[] m = t.ToCharArray();
                    foreach (char item in m)
                    {
                        if (item == '.')
                            throw new MyException("输入的数据应为整数。");
                    }
                    int sum = 1, n = int.Parse(t);
                    do
                    {
                        sum *= n;
                    }
                    while (--n != 0);
                    Console.WriteLine("阶乘为:{0}", sum);
                    Console.ReadKey();
                }
                catch (MyException e)
                {
                    Console.WriteLine(e.Message);
                }
                finally
                {
                    Console.WriteLine("按任意键退出 …");
                    Console.ReadKey();
                }
            }
           
                
        }
    }
    

    展开全文
  • c#用户自定义异常

    2019-09-05 16:56:48
    c#用户可以自己定义异常,自定义异常派生自ApplicationExpection类。 class InputBiggerThanZero : ApplicationException { public InputBiggerThanZero(string message) : base(message) { } } ...

    c#用户可以自己定义异常,自定义异常派生自ApplicationExpection类。

      class InputBiggerThanZero : ApplicationException
        {
            public InputBiggerThanZero(string message) : base(message)
            {
    
            }
    
        }
        class GetInput
        {
            int num;
            public GetInput()
            {
                num = 0;
            }
            public void UserInput(int input)
            {
                if (input <= 0)
                    throw (new InputBiggerThanZero("Input is less than zero!"));
                else
                    Console.WriteLine("Input is {0}", input);
            }
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                int input;
                input=int.Parse( Console.ReadLine());
                GetInput getInput = new GetInput();
                try
                {
                    getInput.UserInput(input);
                }
                catch (InputBiggerThanZero e)
                {
                    Console.WriteLine("{0}",e.Message);
                }
            }
        }

     

    展开全文
  • C# 自定义异常

    2006-05-17 12:09:00
    using System;namespace MyException{ public class DataIsExistException: Exception { public DataIsExistException() { } public DataIsExistException(string message) : base(message) { } public ...
  • 用户自定义异常类 前面已经说了不少关于异常的问题了,现在来给大家说一下自定义异常时咋个回事以及咋样.   为啥会出现自定义异常类呢?用用脚趾头想想也明白,是为了定义咱们自己的异常,自定义异常继承自...
  • C#自定义异常

    2019-02-13 15:09:23
    继承自System.ApplicationException类,并使用Exception作为自定义异常类名的结尾 三个构造函数:一个无参构造函数;一个字符串参数的构造函数;一个字符串参数,一个内部异常作为参数的构造函数 public class ...
  • 自定义异常

    2019-05-15 14:19:41
    需要自定义异常类,继承自系统的异常类。具体需要什么样类型的异常类,就继承自 相应的系统类。 如果你想写一个检查性异常,则需要继承自Exception类 如果你想写一个运行时异常,需要继承自Runti...
  • 异常(Exception)一般分为两大类SystemException
  • C#自定义异常类 在介绍自定义异常类之前我们先看看C#中的默认System.Exception类的元数据。 // 摘要: // 表示在应用程序执行过程中发生的错误。 [Serializable] [ClassInterface(ClassInterfaceType.None)...
  • 摘要:本文解决了C#异常类的自定义问题。我们可以捕获一个通用的异常,识别它和应用程序的关系,然后把它作为特定于应用程序的异常再次抛出,以便能适当地处理它。 首先我们建立自己的C#异常类 CustomException,它...
  • 用户自定义异常类 前面已经说了不少关于异常的问题了,现在来给大家说一下自定义异常时咋个回事以及咋样.   为啥会出现自定义异常类呢?用用脚趾头想想也明白,是为了定义咱们自己的异常,自定义异常继承自...
  • 自定义异常的学习
1 2 3 4 5 ... 20
收藏数 19,189
精华内容 7,675