Question

我的理念是，每当两个或多个相互依赖的操作发生在范围内时，它们应该在TransactionScope中，即使这些单独的操作调用也需要TransactionScope的代码。我的理解是，提供TransactionScope.Required选项可确保如果TransactionScope已经存在，则不会创建新的嵌套，从而解决了嵌套范围令人作呕的问题。

我的问题是“这种方法有什么问题和/或必需的选项不会像我想的那样确保重用TransactionScopes吗？”

以下是我通常会编写的代码示例：

    public void DoDisparateThings()
    {
        using (var transactionScope = new TransactionScope(TransactionScopeOption.Required))
        {
            this.DoThing1();
            this.DoThing2();
            transactionScope.Complete();
        }
    }

    private void DoThing1()
    {
        using (var transactionScope = new TransactionScope(TransactionScopeOption.Required))
        {
            // DB operation 1a
            // DB operation 2a
            transactionScope.Complete();
        }
    }

    private void DoThing2()
    {
        using (var transactionScope = new TransactionScope(TransactionScopeOption.Required))
        {
            // DB operation 1b
            // DB operation 2b
            transactionScope.Complete();
        }
    }
}

我处理的遗留代码有时会将TransactionScope放在链的顶部，而且通常在调用代码时，为什么不需要使用TransactionScope。考虑一下：

    public void CallingCode()
    {
        using (var transactionScope = new TransactionScope())
        {
            this.DoDisparateThings();
            transactionScope.Complete();
        }
    }

    private void DoDisparateThings()
    {
        this.DoThing1();
        this.DoThing2();
    }

    private void DoThing1()
    {
        // DB operation 1a
        // DB operation 2a
    }

    private void DoThing2()
    {
        // DB operation 1b
        // DB operation 2b
    }
}

对我来说这没有任何意义，因为在事务中似乎只发生了一次操作，而其他代码可能无意中调用任何私有方法而没有意识到需要使用事务。 我错了吗？如果发生相关操作需要回滚，如果不能全部成功，那么将TransactionScopes放入代码中会有什么不好吗？

嵌套的TransactionScope哲学和必需的选项

0 个答案: