devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C#异常捕获try catch详细介绍_c# try catch语法

作者：繁依Fanyi0 | 2024-02-19 13:16:19

赞

踩

c# try catch语法

在C#中，异常处理是通过try、catch、finally和throw语句来实现的，它们提供了一种结构化和可预测的方法来处理运行时错误。

C#异常基本用法

try块

异常处理以try块开始，try块包含可能会引发异常的代码。如果在try块中的代码执行过程中发生了异常，控制流将转移到与之匹配的catch块。

try
{
    // 可能会抛出异常的代码
}

  • 1
  • 2
  • 3
  • 4

catch块

catch块紧随try块之后，用于捕获和处理异常。可以有多个catch块来捕获不同类型的异常，每个catch块只处理特定类型的异常。

catch (SpecificExceptionType ex)
{
    // 处理特定类型的异常
}
catch (AnotherExceptionType ex)
{
    // 处理另一种类型的异常
}
catch
{
    // 捕获所有未被前面的catch块处理的异常
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

每个catch块可以指定一个异常变量来接收异常的详细信息，如消息、堆栈跟踪等。

finally块

finally块是可选的，它无论是否发生异常都会执行。finally块通常用于清理资源，比如关闭文件流、数据库连接等。

finally
{
    // 清理代码，无论是否发生异常都会执行
}

  • 1
  • 2
  • 3
  • 4

throw语句

throw语句用于触发异常。你可以重新抛出当前捕获的异常，或者抛出一个新的异常。

throw; // 重新抛出当前异常

throw new Exception("New exception message"); // 抛出一个新的异常

  • 1
  • 2
  • 3

自定义异常

你还可以定义自己的异常类，通过继承System.Exception类来实现。

public class MyCustomException : Exception
{
    public MyCustomException(string message)
        : base(message)
    {
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

然后，你可以像使用内置异常类型一样使用你的自定义异常类型。

完整的异常处理示例

下面是一个展示了如何使用try、catch、finally和throw的完整示例：

using System;

class ExceptionHandlingExample
{
    static void Main()
    {
        try
        {
            Console.WriteLine("Enter a number to divide 100: ");
            int divisor = Convert.ToInt32(Console.ReadLine());
            int result = 100 / divisor;
            Console.WriteLine("Result is: " + result);
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine("Cannot divide by zero. Please try again.");
        }
        catch (FormatException ex)
        {
            Console.WriteLine("That's not a valid number. Please try again.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An unexpected error occurred: {ex.Message}");
            throw; // 可以选择重新抛出异常
        }
        finally
        {
            // 这里的代码不管是否发生异常都会执行
            Console.WriteLine("Thanks for using our program.");
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

在这个例子中，程序尝试将100除以用户输入的数。如果用户输入了非数字或是0，程序将捕获并处理FormatException或DivideByZeroException。无论是否发生异常，finally块都会执行，程序以友好的消息结束。在通用catch块中，异常被重新抛出，这允许异常向上传递，可能被更高级别的异常处理器处理。

异常处理是C#中处理错误的关键部分，能够帮助你创建健壮和易于维护的应用程序。正确使用异常处理能够让你的代码在面对错误时更加优雅地失败，并且提供了足够的信息来帮助调试问题。

自定义异常

在C#中，你可以创建自定义异常以表示应用程序特定的错误情况。自定义异常通常用于提供比标准异常更详细的错误信息或者处理特定于应用程序的错误情况。

要创建自定义异常，你需要从System.Exception类继承，并建议遵循以下步骤：

  1. 命名自定义异常：异常名称通常以“Exception”结尾。
  2. 构造函数：提供几个构造函数，至少要提供与基类Exception相同的四个基本构造函数。
  3. 序列化支持：如果你的异常类需要在不同的应用程序域之间传递（例如，在远程方法调用中），它必须是可序列化的。（需要标记[Serializable]属性，并实现序列化接口）

以下是创建自定义异常的示例：

using System;
using System.Runtime.Serialization;

[Serializable] // 可序列化
public class MyCustomException : Exception
{
    // 默认构造函数
    public MyCustomException()
    {
    }

    // 带错误消息的构造函数
    public MyCustomException(string message)
        : base(message)
    {
    }

    // 带错误消息和内部异常的构造函数（用于异常链）
    public MyCustomException(string message, Exception innerException)
        : base(message, innerException)
    {
    }

    // 实现序列化功能的构造函数
    protected MyCustomException(SerializationInfo info, StreamingContext context)
        : base(info, context)
    {
    }

    // 你可以添加额外的属性和方法来支持你的自定义异常的特殊需求
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

要抛出这个自定义异常，你可以使用throw关键字，像这样：

throw new MyCustomException("This is a custom error message.");

  • 1

如果你需要在异常中包含更多上下文信息，你可以往自定义异常中添加额外的属性和方法。例如，如果你正在处理与用户账户相关的错误，你的自定义异常可能需要包含一个用户ID或用户名属性。

使用自定义异常的好处是能够清晰地表达发生了什么类型的错误，并且可以携带更多的上下文信息。此外，它们使得错误处理代码更加清晰，因为异常类型直接表明了发生的错误，而不必依赖解析错误消息字符串。记住，你应该只在标准异常不足以表达特定错误情况时创建自定义异常。

throw和throw ex有什么区别

在C#中，throw 和 throw ex 用于抛出异常，但它们的行为有重要差异：

  1. throw

    • 使用 throw 关键字不带任何参数重新抛出当前处理的异常。
    • 它保留了原始异常的堆栈跟踪，因此你可以看到异常最初是从哪里抛出的。
    try
{
    // 代码可能抛出异常
}
catch (Exception)
{
    // 处理异常
    throw; // 重新抛出当前异常
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

  2. throw ex

    • 使用 throw ex 重新抛出在 catch 块中捕获的异常变量 ex。
    • 这种方式会重置异常的堆栈跟踪，堆栈跟踪将从当前位置开始，而不是最初抛出异常的位置。
    • 这通常被认为是一种不良的做法，因为它隐藏了引发异常的原始位置，使得调试更加困难。
    try
{
    // 代码可能抛出异常
}
catch (Exception ex)
{
    // 处理异常
    throw ex; // 重新抛出异常，但会丢失原始堆栈跟踪
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

因此，在大多数情况下，如果你需要在 catch 块中重新抛出异常，应该使用 throw 而不是 throw ex 以保留完整的堆栈信息。保持异常的堆栈跟踪对于诊断问题是非常重要的，因为它显示了异常发生的完整调用序列。

然而，如果你的目的是创建并抛出一个全新的异常（可能会附加一些额外的信息），而不是重新抛出原始异常，那么你会创建一个新的异常实例并使用 throw 关键字抛出它：

try
{
    // 代码可能抛出异常
}
catch (Exception ex)
{
    // 创建一个新的异常实例，可能会包含更多信息或者是自定义异常
    throw new MyCustomException("Additional message", ex);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

在这种情况下，MyCustomException 将包含一个内部异常 ex，这样你就可以在处理自定义异常的同时，仍然访问到最初异常的信息。

finally和finalize block的区别

在C#中，“finally”块和“finalize”方法是两个不同的概念，它们用于不同的目的。

finally块

finally块是与try和catch块一起使用的，用于确保无论是否发生异常，都会执行一段代码。finally块常用于资源清理工作，比如关闭文件流、数据库连接等。

这里是一个finally块的示例：

using System;
using System.IO;

class FinallyExample
{
    static void Main()
    {
        FileStream file = null;
        try
        {
            file = File.Open("example.txt", FileMode.Open);
            // 执行一些操作
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        finally
        {
            // 无论是否发生异常，都会执行finally块中的代码
            if (file != null)
            {
                file.Close();
                Console.WriteLine("File stream closed.");
            }
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

在上面的代码中，无论try块中的代码是否成功，或者是否触发了catch块，finally块都会被执行。

finalize方法

finalize方法是一个在对象即将被垃圾回收前执行的清理方法。在C#中，它通过重写Object类的Finalize方法来实现。注意，在.NET中，通常不推荐显式重写Finalize方法，而是建议使用IDisposable接口和Dispose方法来处理资源清理。

这里是一个finalize方法的示例：

using System;

class FinalizeExample
{
    // 析构函数
    ~FinalizeExample()
    {
        // 这里是在对象即将被销毁时会执行的代码
        Console.WriteLine("Finalize method called.");
    }
}

class Program
{
    static void Main()
    {
        FinalizeExample example = new FinalizeExample();
        // 当example不再被使用时，垃圾回收器在回收之前会调用其Finalize方法
        example = null;
        GC.Collect(); // 强制垃圾回收（仅用于示例，通常不建议这么做）
        GC.WaitForPendingFinalizers(); // 等待所有的Finalizer方法执行完毕
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

在这个示例中，FinalizeExample类有一个析构函数（在C#中以~开头），这个析构函数就是Finalize方法的语法糖。当垃圾回收器决定回收这个对象的内存时，会自动调用这个析构函数。

总结

  • finally块是用于异常处理的，确保代码的执行，通常用于释放资源。
  • finalize方法（析构函数）是在对象被垃圾回收前自动调用的，用于执行对象的清理代码。

在实际开发中，finalize方法的使用应该非常谨慎，因为垃圾回收器调用Finalize方法的时间是不确定的。相比之下，IDisposable接口和using语句是更可控、更常见的资源管理机制。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/114901
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号