C#_try语句

try语句定义

try 语句提供一种机制，用于捕捉在块的执行期间发生的各种异常。此外，try 语句还能让您指定一个代码块，并保证当控制离开 try 语句时，总是先执行该代码。

try-statement:
	try   block   catch-clauses
	try   block   finally-clause
	try   block   catch-clauses   finally-clause//你可以有多个cach子句,但只能有一个finally子句
catch-clauses:
	specific-catch-clauses   general-catch-clauseopt
	specific-catch-clausesopt   general-catch-clause
specific-catch-clauses:
	specific-catch-clause
	specific-catch-clauses   specific-catch-clause
specific-catch-clause:
	catch   (   class-type   identifieropt   )   block
general-catch-clause:
	catch   block
finally-clause:
	finally   block

有三种可能的 try 语句形式：

• 一个 try 块后接一个或多个 catch 块。
• 一个 try 块后接一个 finally 块。
• 一个 try 块后接一个或多个 catch 块，后面再跟一个 finally 块。

try示例

需求:两个字符串数值相加的和

	class Program
    {
        static void Main(string[] args)
        {
            Parses p = new Parses();
            int a = p.Add("100", "200");
            Console.WriteLine(a);
        }
        
    }
    class Parses
    {
        public int Add(string arg1,string arg2)
        {
            int a = int.Parse(arg1);
            int b = int.Parse(arg2);
            int result = checked(a + b);
            return result;
        }
    }

上面的代码正常来说是没有问题的但是,当用户输入的值有问题的时候,比如说

 static void Main(string[] args)
        {
            Parses p = new Parses();
            int a = p.Add("100", "200");
            //比如说输入的数值为a或则没有输入,为null的时候程序就会报错,从而崩溃
            Console.WriteLine(a);
        }

try捕捉异常

这个时候就需要使用try语句来捕捉并处理这些异常
首先我们得知道,这些逻辑哪里可能会出现异常

 class Program
    {
        static void Main(string[] args)
        {
            Parses p = new Parses();
            int a = p.Add(null, "200");
            Console.WriteLine(a);
        }
        
    }
    class Parses
    {
        public int Add(string arg1,string arg2)
        {
            int a = int.Parse(arg1);//这里,当arg1为null或不是数字或值溢出的时候会报错
            int b = int.Parse(arg2);//这里也一样
            int result = checked(a + b);//这里会吗?,也会
            //arg1+arg2加起来的值可能会报错,所以这里也需要捕捉一下异常
            return result;
        }
    }

简单实用try修改后的方法

	public int Add(string arg1,string arg2)
	{
	    int a;
	    int b;
	    try
	    {
	        a = int.Parse(arg1);
	        b = int.Parse(arg2);
	    }
	    catch
	    {
	        a = 0;
	        b = 0;
	        Console.WriteLine("你输入的值有问题");
	    }
	    int result = a + b;
	    return result;
	}

精细化的try语句修改后的代码:

阅读csdn文档,我们可以知道Parse方法有三个异常

1. ArgumentNull 值为空
2. Format 非数字
3. Overflow 值溢出

根据这个我们可以使用try精细化捕捉程序可能出现的异常

	public int Add(string arg1,string arg2)
	{
	    int a=0;
	    int b=0;
	    try
	    {
	        a = int.Parse(arg1);
	        b = int.Parse(arg2);
	    }
	    catch(ArgumentException)
	    {
	        Console.WriteLine("你输入的值为空");
	    }
	    catch (FormatException)
	    {
	        Console.WriteLine("你输入的值不为数字");
	    }
	    catch(OverflowException)
	    {
	        Console.WriteLine("");
	    }
	    int result = a + b;
	    return result;
	}

使用标识符将异常输出

我们也可以添加标识符来将异常输出

	public int Add(string arg1,string arg2)
	{
	    int a=0;
	    int b=0;
	    try
	    {
	        a = int.Parse(arg1);
	        b = int.Parse(arg2);
	    }
	    catch(ArgumentNullException ane)
	    //标识符是可省的
	    //catch 抓住异常之后,产生的实例使用ane来接收
	    {
	        Console.WriteLine(ane);//输出刚刚的异常
	    }
	    catch (FormatException fe)
	    {
	        Console.WriteLine(fe);
	    }
	    catch(OverflowException oe)
	    {
	        Console.WriteLine(oe);
	    }
	    finally//不管程序有没有异常,都会执行
	    {
	    //finally一般用于关闭各种链接的.
	    //比如当系统链接了数据库hi,执行关闭连接的代码块出现了异常
	    //这个finally就可以将系统链接关闭,用于执行异常
	    }
	    int result = a + b;
	    return result;
	}

throw

就是抛出一个异常，并获取这个异常的引用，这个异常会被抛到外部的环境，由外部环境进行处理这里抛出了一个Exception,Exception是throwable的子类，是所有异常的基类。与此同时,throwable还有另一个子类，也就是Error。这里会把Exception这个引用抛到外部环境中去处理。

• 这里我们使用上面的代码来继续讲throw

	public int Add(string arg1,string arg2)
	{
	    int a=0;
	    int b=0;
	    try
	    {
	        a = int.Parse(arg1);
	        b = int.Parse(arg2);
	    }
	    catch(ArgumentNullException ane)
	    //标识符是可省的
	    //catch 抓住异常之后,产生的实例使用ane来接收
	    {
	        Console.WriteLine(ane);//输出刚刚的异常
	    }
	    catch (FormatException fe)
	    {
	        Console.WriteLine(fe);
	    }
	    catch(OverflowException oe)
	    {
	       // Console.WriteLine(oe); //在这里我处理这个异常,
	       throw oe ;//我们直接将这个可能出现的异常oe抛出给调用者,让他处理这个可能出现的异常
	       
	    }
	    finally//不管程序有没有异常,都会执行
	    {
	    //finally一般用于关闭各种链接的.
	    //比如当系统链接了数据库hi,执行关闭连接的代码块出现了异常
	    //这个finally就可以将系统链接关闭,用于执行异常
	    }
	    int result = a + b;
	    return result;
	}

• 那抛出的异常怎么处理呢?
• 谁调用谁处理,示例如下

	static void Main(string[] args)
	{
	    Parses p = new Parses(); //这里调用了刚刚的那个放发就有可能出现overflow的异常
	    int a = 0;
	    try
	    {
	       a= p.Add(null, "200");
	    }
	    catch (Exception oe)
	    {
	
	        Console.WriteLine(oe);
	    }
	    Console.WriteLine(a);
	}