Как определить, обрабатывается ли исключение .NET?

http://www.codewrecks.com/blog/index.php/2008/07/25/detecting-if-finally-block-is-executing-for-an-manhandled-exception/ описывает «взлом», чтобы определить, выполняется ли ваш код в режиме обработки исключений или нет. Он использует Marshal.GetExceptionPointers, чтобы узнать, является ли исключение «активным».

Но имейте в виду:

Замечания

GetExceptionPointers предоставляется только для поддержки компилятором структурированной обработки исключений (SEH). Примечание Примечание:

Этот метод использует SecurityAction.LinkDemand для предотвращения его вызова из ненадежного кода; только непосредственный вызывающий должен иметь разрешение SecurityPermissionAttribute.UnmanagedCode. Если ваш код может быть вызван из частично доверенного кода, не передавайте вводимые пользователем данные в методы класса Marshal без проверки. О важных ограничениях на использование члена LinkDemand см. В разделе «Спрос против LinkDemand».

Не ответ на вопрос, а просто примечание о том, что я никогда не использовал «принятый» хак в реальном коде, так что он все еще в значительной степени не протестирован «в дикой природе». Вместо этого мы пошли примерно так:

DoThings(x =>
{
    x.DoSomething();
    x.DoMoreThings();
});

где

public void DoThings(Action<MyObject> action)
{
    bool success = false;
    try
    {
        action(new MyObject());
        Commit();
        success = true;
    }
    finally
    {
        if (!success)
            Rollback();
    }
}

Ключевым моментом является то, что он такой же компактный, как пример «использования» в вопросе, и не использует никаких хаков.

Среди недостатков - снижение производительности (совершенно незначительное в нашем случае) и переход F10 в DoThings, когда я действительно хочу, чтобы он просто переходил прямо к x.DoSomething(). Оба очень второстепенные.

Эта информация вам недоступна.

Я бы использовал шаблон, аналогичный тому, который используется в классе DbTransaction: то есть ваш класс IDisposable должен реализовывать метод, аналогичный DbTransaction.Commit (). Затем ваш метод Dispose может выполнять различную логику в зависимости от того, был ли вызван Commit (в случае DbTransaction, транзакция будет отменена, если она не была зафиксирована явно).

Затем пользователи вашего класса будут использовать следующий шаблон, аналогичный типичному DbTransaction:

using(MyDisposableClass instance = ...)
{
    ... do whatever ...

    instance.Commit();
} // Dispose logic depends on whether or not Commit was called.

ИЗМЕНИТЬ. Я вижу, что вы изменили свой вопрос, чтобы показать, что вы знаете об этом шаблоне (в вашем примере используется TransactionScope). Тем не менее я считаю, что это единственно реальное решение.

Оператор using - это просто синтаксический сахар для блока try finally. Вы можете получить то, что хотите, написав, наконец, попытку полностью, а затем добавив оператор catch для обработки вашего особого случая:

try
{
    IDisposable x = new MyThing();
}
catch (Exception exception) // Use a more specific exception if possible.
{
    x.ErrorOccurred = true; // You could even pass a reference to the exception if you wish.
    throw;
}
finally
{
    x.Dispose();
}

Внутри MyThing вы можете сделать это, если хотите, например:

class MyThing : IDisposable
{
    public bool ErrorOccurred() { get; set; }

    public void Dispose()
    {
        if (ErrorOccurred) {
            RollBack();
        } else {
            Commit();
        }
    }
}

Примечание: я также должен задаться вопросом, почему вы хотите это сделать. Есть запах кода. Метод Dispose предназначен для очистки неуправляемых ресурсов, а не для обработки исключений. Вероятно, вам будет лучше написать код обработки исключений в блоке catch, а не в dispose, и если вам нужно поделиться кодом, сделайте несколько полезных вспомогательных функций, которые вы можете вызывать из обоих мест.

Вот лучший способ делать то, что вы хотите:

using (IDisposable x = new MyThing())
{
    x.Foo();
    x.Bar();
    x.CommitChanges();
}

class MyThing : IDisposable
{
    public bool IsCommitted { get; private set; }

    public void CommitChanges()
    {
        // Do stuff needed to commit.
        IsCommitted = true;
    }

    public void Dispose()
    {
        if (!IsCommitted)
            RollBack();
    }
}

Это не кажется такой уж плохой идеей; это просто не кажется идеальным в C # /. NET.

В C ++ есть функция, которая позволяет коду определять, вызван ли он из-за исключения. Это наиболее важно в деструкторах RAII; деструктор может выбрать фиксацию или прерывание в зависимости от того, является ли поток управления нормальным или исключительным. Я думаю, что это довольно естественный подход, но отсутствие встроенной поддержки (и морально сомнительная природа обходного пути; мне кажется, что это скорее зависит от реализации), вероятно, означает, что следует использовать более традиционный подход.