Обнаружение Расположения () от исключения в использовании блока

Посмотрите на дизайн TransactionScope в System.Transactions. Их метод требует, чтобы вы вызывали Complete () в области транзакции, чтобы зафиксировать транзакцию. Я бы подумал о том, чтобы спроектировать ваш класс базы данных, следуя тому же шаблону:

using (var db = new Database()) 
{
   ... // Do some work
   db.Commit();
}

Вы, возможно, захотите ввести концепцию транзакций вне вашего объекта базы данных. Что произойдет, если потребители захотят использовать ваш класс и не хотят использовать транзакции и все будут автоматически фиксировать?

Все остальные уже написали, каким должен быть правильный дизайн вашего класса Database , поэтому я выиграл » Я повторяю это. Однако я не видел никаких объяснений, почему то, что вы хотите, невозможно. Итак, вот оно.

Что вы хотите сделать, так это определить во время вызова Dispose , что этот метод вызывается в контексте исключения. Когда вы сможете это сделать, разработчикам не придется явно вызывать Commit . Однако проблема здесь в том, что в .NET нет способа надежно обнаружить это. Хотя существуют механизмы для запроса последней выданной ошибки (например, HttpServerUtility.GetLastError ), эти механизмы зависят от хоста (поэтому ASP.NET имеет другой механизм, например, формы Windows). И хотя вы можете написать реализацию для конкретной реализации хоста, например, реализацию, которая будет работать только в ASP.NET, есть еще одна более важная проблема: что, если ваш класс Database используется или создается в контексте исключения? Вот пример:

try
{
    // do something that might fail
}
catch (Exception ex)
{
    using (var database = new Database())
    {
        // Log the exception to the database
        database.Add(ex);
    } 
}

Когда ваш ] Класс базы данных используется в контексте исключения , как в примере выше, как ваш метод Dispose должен знать, что он все еще должен выполнить фиксацию? Я могу придумать способы обойти это, но это будет довольно хрупко и подвержено ошибкам. Приведу пример.

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

Хотя это кажется хорошим решением, как насчет этого примера кода?

var logger = new Database();
try
{
    // do something that might fail
}
catch (Exception ex)
{
    logger.Add(ex);
    logger.Dispose();
}

В этом примере вы видите, что экземпляр Database создается перед блоком try. Поэтому он не может правильно определить, что не может откатиться. Хотя это может быть надуманный пример, он показывает трудности, с которыми вы столкнетесь при попытке спроектировать свой класс таким образом, чтобы явный вызов Commit не требовался.

В конце концов, вы сделаете свой класс Database сложным для проектирования и поддержки, и вы никогда не поймете это правильно.

Как уже говорили все остальные, проект, который требует явного вызова Commit или Complete , будет проще реализовать, легче получить правильные, проще в обслуживании и дает возможность использовать код более читабельный (например, потому что он выглядит так, как ожидают разработчики).

Последнее замечание, если вы беспокоитесь о том, что разработчики забывают вызвать этот метод Commit : вы можете выполнить некоторую проверку в методе Dispose , чтобы узнать, вызывается ли он без ] Commit вызывается и записывает в консоль или устанавливает точку останова во время отладки. Кодировать такое решение было бы намного проще, чем пытаться вообще избавиться от Commit .

Обновление: Адриан написал интересную альтернативу использованию HttpServerUtility.GetLastError. Как отмечает Адриан, вы можете использовать Marshal.GetExceptionPointers () , который является общим способом, который будет работать на большинстве хостов. Обратите внимание, что это решение имеет те же недостатки, о которых говорилось выше, и что вызов класса Marshal возможен только при полном доверии

Похоже, вам нужно TransactionScope http://msdn.microsoft.com/en-us/library/system.transactions.transactionscope.aspx

Как указывает Энтони выше, проблема заключается в том, что вы ошиблись в использовании предложения using в этом сценарии. Парадигма IDisposable предназначена для обеспечения очистки ресурсов объекта независимо от результата сценария (поэтому исключение, возврат или другое событие, которое покидает блок using, по-прежнему запускает метод Dispose). Но вы изменили его назначение, чтобы оно означало что-то другое, чтобы совершить транзакцию.

Мое предложение было бы таким, как заявляли другие, и использовать ту же парадигму, что и TransactionScope. Разработчик должен явно вызвать Commit или аналогичный метод в конце транзакции (до закрытия блока using), чтобы явно сказать, что транзакция исправна и готова к фиксации. Таким образом, если исключение заставляет выполнение покинуть блок using, метод Dispose в этом случае может вместо этого выполнить откат. Это все еще соответствует парадигме, поскольку выполнение отката было бы способом «очистки» объекта базы данных, чтобы он не оставался в недопустимом состоянии.

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

Вы можете унаследовать от класса Database, а затем переопределить метод Dispose () (убедившись, что ресурсы базы данных закрыты), тогда это может вызвать настраиваемое событие на который вы можете подписаться в своем коде.

Вы должны заключить содержимое вашего блока using в блок try / catch и откатить транзакцию в блоке catch:

using (var database = new Database()) try
{
    var poll = // Some database query code.

    foreach (Question question in poll.Questions) {
        foreach (Answer answer in question.Answers) {
            database.Remove(answer);
        }

        // This is a sample line  that simulate an error.
        throw new Exception("deu pau"); 

        database.Remove(question);
    }

    database.Remove(poll);
}
catch( /*...Expected exception type here */ )
{
    database.Rollback();
}

Короче: я думаю, что это невозможно, НО

Что вы можете сделать, так это установить флаг в своем классе базы данных со значением по умолчанию "false" (это нехорошо) и дальше в последней строке внутри блока using вы вызываете метод, который устанавливает для него значение «true», затем в методе Dispose () вы можете проверить, имеет ли флаг «исключение» или нет.

using (var db = new Database())
{
    // Do stuff

    db.Commit(); // Just set the flag to "true" (it's good to go)
}

И класс базы данных

public class Database
{
    // Your stuff

    private bool clean = false;

    public void Commit()
    {
        this.clean = true;
    }

    public void Dispose()
    {
        if (this.clean == true)
            CommitToDatabase();
        else
            Rollback();
    }
}