用於處理的設計模式（如果使用不同的實現）

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