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

Question

I have the following two types of processors

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

Most of the implementation code is exactly the same (error checking etc) except one returns a value. Is there a pattern to clean this up?

Answer 1

Yes, there is.

Define both methods on the same interface:

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

And then:

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

There are many ways you can do this. One thing you have to keep in mind is that there is no way you can have a method with a optional return. That been said, you can try one of the aproaches below:

Implement Template Pattern and return null to your process that don't return anything:

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

Create an Interface with both methods, and then choose what is the best method to call (as pointed by 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
    }
}

Create an Interface with a single method and decide if you will return something (or null) based on the type:

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