C# 如何避免重复；使用；代码

我有一个wcf api，希望将所有请求封装在事务中

目前，我的代码在每个端点中都是这样的

public MyCompleteList ReadOrganisations()
    {
        MyCompleteList resp = new MyCompleteList ();
        try
        {
            using (TransactionScope scope = new TransactionScope())
            {
                if (HttpContext.Current.User.Identity.IsAuthenticated)
                {
                    DC_Base browser_request = new DC_Base(PROJECT);
                    browser_request.cmd_user_id = coreDb.GetUserIDFromLoginName(PROJECT,
                        HttpContext.Current.User.Identity.Name);
                    resp =
                        new MyCompleteList (coreSc.User_Read_All_Organisations(browser_request, utils,
                            validation, coreSc, coreDb));
                    scope.Complete();
                }
                else
                {
                    resp.SetResponseNotLoggedIn();
                }

            }
        }
        catch (TransactionAbortedException ex)
        {
            resp.SetResponseServerError();
        }
        catch (ApplicationException ex)
        {
            resp.SetResponseServerError();
        }
        return resp;
    }

如您所见，如果我要在每个端点（大约300个）中使用“使用”事务范围部分，那么将有大量重复的代码

---

有没有办法减少复制量？

您可以编写一个helper方法，在将实际代码作为lambda调用时处理事务逻辑

    public static T Execute<T>(Func<T> func, TransactionExecutionOptions options = null)
    {
        options = options ?? TransactionExecutionOptions.Default;

        T res;
        using (var tx = new TransactionScope(options))
        {
            res = func();
            tx.Complete();
        }

        return res;
    }

如果可能的话，还可以将

SetResponse*（）

方法分解成基类或接口（比如IMyResponse），这样就可以在

Execute

方法内部处理这一方面

    public static T Execute<T>(Func<T> func, TransactionExecutionOptions options = null) where T : IMyResponse
    {
        options = options ?? TransactionExecutionOptions.Default;

        T res;
        try
        {
            using (var tx = new TransactionScope(options))
            {
                res = func();
                tx.Complete();
            }
        }
        catch (TransactionAbortedException ex)
        {
            res.SetResponseServerError();
        }
        catch (ApplicationException ex)
        {
            res.SetResponseServerError();
        }
        return res;
    }

public static T Execute（Func Func，TransactionExecutionOptions=null），其中T:IMyResponse
{
选项=选项？？TransactionExecutionOptions.Default；
T res；
尝试
{
使用（var tx=新事务处理范围（选项））
{
res=func（）；
tx.Complete（）；
}
}
捕获（TransactionBortedException ex）
{
res.SetResponseServerError（）；
}
捕获（ApplicationException ex）
{
res.SetResponseServerError（）；
}
返回res；
}

1-创建一个ServiceBase类，如下所示

public class ServiceBase
    {

       protected void ExecuteOperation(Action codetoExecute)
        {                               
            try
            {               
                 using (TransactionScope scope = new TransactionScope())
                {                   
                    codetoExecute.Invoke();             
                    scope.Complete();                
                }                           
            }
            catch (TransactionAbortedException ex)
            {
                // handle exception
            }
            catch (ApplicationException ex)
            {
                // handle exception
            }            
        }
    }

2-每个新服务必须继承自ServiceBase，并调用ExecuteOperation。代码如下：

ExecuteOperation(() =>
            {                 
                 // Custom code here
            });

---

3-原子事务在执行不期望返回结果的操作时非常有用。

是的，创建父类，将代码移到其中。这是什么意思？你能提供一些更详细的信息吗？这个wcf服务当前从一个接口继承到基类，然后再继承到一个顶级类。你说添加父类是什么意思？这些函数是由外部客户机（也称为JSONY）调用的。您的问题不是很清楚，“使用”是如何导致代码重复的？如果我想在来自客户机的每个端点调用中使用事务，那么我需要使用（…）在每个有大量重复的端点中，示例只是我们的API提供的许多端点中的一个。另外，请不要使用SQL Server的可序列化事务。将TransactionScope更改为“已提交”。看，好的，这看起来像我在想的，我可以给它一个测试，谢谢你的回答。是的，我已经在所有响应继承的接口中有响应，所以这看起来更好

ExecuteOperation(() =>
            {                 
                 // Custom code here
            });