重构类以避免在每个方法中编写相同的模式

Question

我有一个类,有很多静态方法来管理数据库操作.所有方法都遵循以下模式:

try
{
   using(var trans = new TransactionScope())
   {
      using(var context = new DBContext())
      {
         . . . // method body
      }
      trans.Complete();
   }
}
catch(Excepcion ex)
{
   Log.Error(ex.Message);
   if (ex.InnerException != null)
      Log.Error(ex.InnerException.Message);
}

如何重构我的代码,以便不需要在每个方法中编写这个结构？

编辑实施Jon的回复.

public static T TransactionalOperation<T>(Func<DBContext, T> databaseAction)
{
   T retVal = default(T);
   try
   {
      using (var trans = new TransactionScope())
      {
         using (var context = new DBContext())
         {
            if (databaseAction != null)
               retVal = databaseAction(context);
         }
         trans.Complete();
   }
   catch (Exception ex)
   {
      Log.Error(ex.ToString());
   }
   return retVal;
}
public static void TransactionalOperation(Action<DBContext> databaseAction)
{
   TransactionalOperation(context =>
      {
         databaseAction(context);
         return string.Empty;
      });
}

像这样使用:

public static string GetUserLanguage(string owner)
{
   return
      TransactionalOperator(context => context.clients.Single(c => c.Id == owner).Language);
}    

Answer 1

听起来你应该作为委托传递"方法体":

public void GiveMeAProperName(Action<DBContext> databaseAction)
{
    try
    {
       using(var trans = new TransactionScope())
       {
          using(var context = new DBContext())
          {
             . . . // method body
          }
          trans.Complete();
       }
    }
    catch(Exception ex)
    {
       Log.Error(ex.Message);
       if (ex.InnerException != null)
          Log.Error(ex.InnerException.Message);
    }
}

然后你可以用:

GiveMeAProperName(context =>
{
    // Do stuff with your context here
});

如评论中所述,您可能希望重载:

public void GiveMeAProperName<T>(Func<DBContext, T> databaseAction)

这样你就可以返回一个值.你可以轻松编写你的Action重载来委托给那个:

public void GiveMeAProperName(Action<DBContext> databaseAction)
{
    GiveMeAProperName(context =>
    {
        databaseAction(context);
        return "ignored";
    }
}

我强烈建议不同的异常处理:

• 您只记录消息.为什么你认为堆栈跟踪不重要？只记录整个异常 - 包括嵌套异常等
• 你事后有效地忽略了失败.在大多数情况下,我个人会完全删除try/catch ...在非常高的级别捕获异常,而不是在执行数据库操作的级别.