Question

我有一个C＃程序，其中包含具有不同参数和不同返回类型的多种方法，但是大多数方法具有具有相同异常逻辑处理的try / catch块。所有方法都有多个catch语句，但是它们内部的逻辑对于所有方法都是相同的。

有没有一种创建助手方法的方法，这样我就不会在代码中出现重复的代码了？

    public static async Task<long> Method1(string requestedKey)
    {
        try
        {
            //code
            return value;
        }
        catch (Exception1 ex)
        {
            Exception1Handler(ex);
        }
        catch (Exception2 ex)
        {
            Exception2Handler(ex);
        }
        catch (Exception3 ex)
        {
            Exception3Handler(ex);
        }
        catch (Exception ex)
        {               
        }

        return 0;
    }


    public static async Task<T> Method2(string key, string value)
    {
        try
        {
            //code
            return value;
        }
        catch (Exception1 ex)
        {
            Exception1Handler(ex);
        }
        catch (Exception2 ex)
        {
            Exception2Handler(ex);
        }
        catch (Exception3 ex)
        {
            Exception3Handler(ex);
        }
        catch (Exception ex)
        {               
        }

         return default(T);
    }

如何将catch语句分组为一个辅助方法，以使我没有重复的代码？

Answer 1

如果要避免重复使用catch块，则可以使用以下方法

public void HandleException(Action action)
{
    try
    {
        action();
    }
    catch (Exception1 e)
    {
        // Exception1 handling
    }
    catch (Exception2 e)
    {
        // Exception2 handling
    }
    catch (Exception3 e)
    {
        // Exception3 handling
    }
    catch (Exception e)
    {
        // Exception handling
    }
}

...

HandleException(() => /* implementation */)

Answer 2

而不是这样：

void AA(string B)
{
    try
    {
        //Do something
    }
    catch (Exception)
    {
        //Do something else
    }
}

void AA(string B, string C)
{
    try
    {
        //Do something
    }
    catch (Exception)
    {
        //Do something else
    }
}

并一遍又一遍地键入相同的异常（我想他们会完全一样，因为您在问题中这样说）您可以执行以下操作：

void CallerMethod()
{
    try
    {
        AA("");
        AA("", "");
    }
    catch (Exception)
    {
        //My only one exception
    }
}

void AA(string B)
{
    //Do something
}

void AA(string B, string C)
{
    //Do something
}

这样，如果您的任何重载方法都将引发异常，则只能在1个地方处理它们

具有相同try / catch逻辑的多种方法

2 个答案: