用于处理的设计模式（如果使用不同的实现）

Question

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

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;
        }
    }
}

大多数实现代码是完全相同的（错误检查等），只是返回一个值。 有没有一种模式可以解决这个问题？

Answer 1

就在这里。

在同一接口上定义两个方法：

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;
         }
     }
}

Answer 2

您可以通过多种方式执行此操作。 您要记住的一件事是，您不可能有一个带有可选返回值的方法。 话虽如此，您可以尝试以下方法之一：

实现模板模式，并向不返回任何内容的过程返回null：

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;
    }
}

使用这两种方法创建一个接口，然后选择最佳的调用方法（如MatiasCí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
    }
}

使用单个方法创建一个Interface并根据类型决定是否返回某些值（或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
    }
}