用于处理不同实现的 if else 的设计模式

Design pattern for handling if else with different implementations

我有以下两种类型的处理器

public interface IDefaultProcessor1
{
    void Process(IProcess p);
}

public interface IDefaultProcessor2
{
    T Process<T>(IProcess p);
}

public class DefaultProcessor : IDefaultProcessor1
{
    public void Process(IProcess p)
    {
        try
        {
            foreach ...
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
            throw;
        }
    }
}

public class AnotherProcessor : IDefaultProcessor2
{
    public T Process<T>(IProcess p)
    {
        try
        {
            foreach ...
            return p.Result()...
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
            throw;
        }
    }
}

大部分实现代码完全相同(错误检查等),除了一个 returns 值。有清理这个的模式吗?

是的,有。

在同一接口上定义两种方法:

public interface IDefaultProcessor
{
    void Process(IProcess p);
    TResult Process<TResult>(IProcess p);
}

然后:

public class DefaultProcessor : IDefaultProcessor
{
     public void Process(IProcess p)
     {
         DoProcess(p);
     }

     public TResult Process<TResult>(IProcess p)
     {
         object result = DoProcess(p);
         return (TResult)result;
     }

     private object DoProcess(IProcess p)
     {
         try
         {
             foreach ...
             return p.Result();
         }
         catch(Exception ex)
         {
              Console.WriteLine(ex.Message);
              throw;
         }
     }
}

有多种方法可以做到这一点。您必须牢记的一件事是,您无法拥有带有可选 return 的方法。话虽如此,您可以尝试以下方法之一:

为您的进程实施模板模式和 return null,但 return 没有任何东西:

public abstract class AbstractProcess<T>
{
    public abstract T DoProcess();

    public T Process()
    {
        //do your common tasks

        return DoProcess();
    }
}

public class Process1 : AbstractProcess<Process1>
{
    public override Process1 DoProcess()
    {
        return new Process1();
    }
}

public class Process2 : AbstractProcess<Process2>
{
    public override Process2 DoProcess()
    {
        return null;
    }
}

使用这两种方法创建一个接口,然后选择调用的最佳方法(如 Matias Cícero 所指出的)

public interface IProcessor
{
    T Process<T>();
    void Process();
}

public class Processor : IProcessor
{
    public void Process()
    {
        DoWork();
    }

    public T Process<T>()
    {
        return (T)DoWork();
    }

    public object DoWork()
    {
        // do your common tasks
    }
}

使用单一方法创建一个接口,并根据类型决定是否 return 某些东西(或 null):

public interface IProcessor
{
    T Process<T>() where T : class;
}

public class Processor : IProcessor
{
    public T Process<T>() where T : class
    {
        var result = (T)DoWork();

        if (typeof(T) == typeof(Process2))
            return result;

        return null;
    }

    public object DoWork()
    {
        // do your common tasks
    }
}