如何确保操作不会使整个应用程序崩溃？

Question

我有一个应用程序执行一些额外的工作，例如清理旧日志、发送通知等。如果一项工作失败，我不希望整个应用程序停止工作并且不执行剩下的工作。

例如，

await SendUsersBirthdayEmailsAsync(); // <-- if something fails while trying to send birthday emails here, I don't want the app to stop working and not clean logs and so on...
await DeleteOutdatedLogsAsync();
await SendSystemNotificationsAsync();

你会推荐我一起去吗？

Answer 1

在可能失败的代码的每个部分使用try-catch 块。
根据您的需要，使用try-catch-finally 块。

在每个catch 块上，根据需要记录异常。我使用 Nlog 进行日志记录，所以我建议调查一下。

try{
    //do work here
}
catch(Exception e){
    //log exception here
}
//optional
finally{
    //do optional needed work here
}

类似这样的：

public bool SendUsersBirthdayEmailsAsync(){
    try{
        SendMail();
    }
    catch(Exception e){
        LogException(e);
    }
    //optional
    finally{
        OptionalWork();
    }       
}

编辑：关于避免使用泛型异常

您始终可以使用多个catch 块来为每种异常类型定义不同的行为。当您知道可以预期什么样的异常时，这很有用。
示例：

public bool SendUsersBirthdayEmailsAsync(){
    try{
        SendMail();
    }
    catch (ThreadAbortException tae)
    {
        LogException(tae);
        //do something specific
    }
    catch (ThreadInterruptedException tie)
    {
        LogException(tie);
        //do something specific
    }
    catch(Exception e){
        LogException(e);
    }
    //optional
    finally{
        OptionalWork();
    }       
}

编辑 2：Official Microsoft guidance 用于异常处理。

在可能产生异常的代码周围使用try/catch 块，并且您的代码可以从该异常中恢复。在catch 块中，始终将异常从最衍生到最小的顺序排列。所有异常都源自Exception。更多派生异常不会由 catch 子句处理，该子句前面是基异常类的 catch 子句。当您的代码无法从异常中恢复时，不要捕获该异常。如果可能，使调用堆栈更靠前的方法能够恢复。

清理使用using 语句或finally 块分配的资源。首选using 语句在抛出异常时自动清理资源。使用finally 块来清理没有实现IDisposable 的资源。即使抛出异常，finally 子句中的代码也几乎总是被执行。

Answer 2

Task<Task> task = (SendUsersBirthdayEmailsAsync()
            .ContinueWith(x => Task.WhenAll(DeleteOutdatedLogsAsync(), SendSystemNotificationsAsync())));
await await task;

对于更一般的示例，提供以下代码：

class TaskTest
{
    public async void Start()
    {

        await (
            (await One().ContinueWith(x => Task.WhenAll(Two(), Three())))
            .ContinueWith(x=> Four()));
    }

    private async Task One()
    {
        await Task.Delay(5000);
        Console.WriteLine("1");
        throw new Exception();
    }

    private async Task Two()
    {
        await Task.Delay(2000);
        Console.WriteLine("2");
        throw new Exception();

    }
    private async Task Three()
    {
        await Task.Delay(3000);
        Console.WriteLine("3");
        throw new Exception();
    }

    private async Task Four()
    {
        await Task.Delay(1000);
        Console.WriteLine("4");
        throw new Exception();
    }
}

运行此代码表明在任务中抛出异常不会停止整个程序。

Answer 3

如果您已经在使用调度程序执行此操作，为什么不将其分成更小的任务呢？这样，如果一个动作失败，它不会降低所有其他动作。此外，拥有许多具有专门职责的小型应用程序而不是一个通用的应用程序是一种很好的做法。

Answer 4

如果您正在寻找一个可靠的选项来确保流程已完成且可追溯，您可以选择Hangfire。您还可以通过处理异常来放置重试逻辑以防失败。

Answer 5

由于方法的名称表明这些方法是相互独立的，只需确保每个方法都返回一个可等待的任务并将它们放入一个列表中。您对await 的使用表明，他们已经这样做了。

在其周围放置一个 try-catch 并捕获 AggregateExeption。

List<Task> tasks = new List<Task>();
try
{
  tasks.Add(SendUsersBirthdayEmailsAsync());
  tasks.Add(DeleteOutdatedLogsAsync());
  tasks.Add(SendSystemNotificationsAsync());

  Task.WhenAll(tasks); // waits for all tasks to finish
}
catch (Exception e)
{
   //Log e.ToString(); will give you all inner exceptions of the aggregate exception as well, incl. StackTraces, so expect possibly a lot of chars, wherever you log it.
}

这也可能会加快速度，因为它们现在是并行运行的。但由于它们似乎都在数据库上工作（很可能是相同的），由于调度开销，它可能不会太多，如果有的话。

Answer 6

您可以使用Try-Pattern 实现您的方法并让它们返回布尔值。 让每个方法自己处理异常，这样您就可以确定不会抛出未处理的异常来杀死您的应用程序。

如果失败会导致程序状态不可恢复，这些方法应返回 false，并且您的应用程序应自行以干净的方式退出。

Answer 7

未观察到的任务异常

await SendUsersBirthdayEmailsAsync(); // uses TaskScheduler

由于您使用的是 TaskScheduler，请查看 TaskScheduler.UnobservedTaskException。

当故障任务的未观察到的异常即将触发时发生 异常升级策略，默认情况下会终止 过程。

Answer 8

您需要在每个函数中使用 Try-Catch，如下所示。

try{
    //write your code
}
catch(Exception e){
    //your exception will be here
}

您可以为该异常生成一个日志文件。 只需为您的日志文件做一件事。创建一个日志类和一个日志文件生成函数。 在所有函数的捕获区域中调用该函数。

让您创建一个名为 clsLog 的 Log 类。和一个名为 InsertLog(string exception, string functionname).

的静态函数

在你的所有函数中使用这个日志方法，如下所示。

public void insertcity()
{
 try
 {
   //Insert city programming
 }
 catch (exception ex)
 {
   clsLog.InsertLog(ex.Message,"insertCity");
   //do something else you want.
 }        
}

希望它会有所帮助。

Answer 9

我想如果你使用

try{
    //your nice work
}
catch(Exception e){
    //hmm.. error ok i will show u
}
//optional
finally{
    //again start the operation if u failed here.
}

我还制作了相同的应用程序，其中当出现一些错误并失败时，我会在 catch 异常中登录系统，并在 finally 中再次重新启动应用程序。所以它永远不会死。

Answer 10

我建议找出您从 async 获得的异常以实际获取此异常并了解您可以在主要 Thread 上使用它：

MyTask().GetAwaiter().GetResult();

这将允许您查看您在 await 线程上的实际异常的文本。

---

如果您不希望主线程返回到 await 的行，您也可以使用：

await SendUsersBirthdayEmailsAsync().ConfigureAwait(false);

这只会在最近的空闲线程上继续您的任务。

但是不得不说这会在Android上引发异常，因为它在使用Threads上有一些限制。

---

如果您不想浪费时间或不需要手动处理异常并修复它try, catch finally 始终是一个选项。

Answer 11

Andreas 使用的 answer - 符合我的想法 - 但我会再制作一件 - 取消令牌 - 有时间限制，您认为时间足够长 - 以便一切完成。

Wait 中的各个任务意味着它们在各自执行时都在该点一起返回。如果发生聚合门异常，您可以捕获它们 - 然后确定它是否超时 - 或者您需要记录的内容。

还应该包括关于 UnhandledException 和 UnhandledTask Exception 的两条建议 - 无论出于何种原因，它们都会停止。

我还会考虑将其设为 Windows 服务，以便您可以从启动时将取消令牌传递给任务 - 并在服务实际运行时设置计时器 - 而不是计划任务 - 然后进行所有异常处理随着时间的推移，您可以看到日志告诉您的内容——对我来说，这比控制台应用程序更有弹性——但这就是我们通常以这种方式运行任务的方式。

您可以在控制台应用程序中启动和停止这样的服务以进行测试 - 然后将其交给处理 OnStart 和 OnStop 事件的项目 - 传递取消令牌 - OnStop 将取消令牌并停止服务循环。