如何在 C# 中强制执行方法的顺序

Question

长话短说，我有以下课程：

public class FlowBasePipeline<T>
{
    private List<StepBaseBusiness<T>> stepList = new List<StepBaseBusiness<T>>();
    
    public void Push(StepBaseBusiness<T> step)
    {
        stepList.Add(step);
    }
    
    public void Trigger(T result)
    {
        foreach (var step in stepList )
        {
            result = step.Execute(result);
            if (!result.IsSuccess)
            {
                break;
            }
        }
    }
}

我正在寻找的是强制程序员首先调用Push 方法，然后让他们访问Trigger 方法，在这种情况下，以下情况是不允许的

var pipeline=new FlowBasePipeline<MyStepResult>();
pipeline.Trigger()// Trigger method is not recognized

我们应该先调用Push方法

var pipeline=new FlowBasePipeline<MyStepResult>();
pipeline.Push(new MyStep()).Trigger()//Now Trigger is recognized

我做了什么：

我应用了如下显式接口方法实现以使其工作：

public interface IBasePipeline<T> where T:BaseResult,new()
{
    void Trigger();
    IBasePipeline<T> Push(StepBaseBusiness<T> step);
}


  public class FlowBasePipeline<T>:IBasePipeline<T> where T:BaseResult,new()
   {
          private List<StepBaseBusiness<T>> stepList = new List<StepBaseBusiness<T>>();
        
            public IBasePipeline<T> Push(StepBaseBusiness<T> step)
                {
                    stepList.Add(step);
                    return this;
                }
        
                void IBasePipeline<T>.Trigger(T result)
                {
                    foreach (var step in stepList )
                    {
                        result = step.Execute(result);
                        if (!result.IsSuccess)
                        {
                            break;
                        }
        
                    }
                }
    }

现在它运行良好，我们无法在 Push 方法之前访问 Trigger 方法，但从我的角度来看，这不是一个好方法，因为我们可能需要更多级别的订单，我不知道怎么做可以通过这种方式完成。

据我所知，方法链是函数式编程的关键规则之一。

是否有任何模式或策略来实现这种链接？

更新：

我们需要多次调用push方法

var pipeline=new FlowBasePipeline<MyStepResult>();
pipeline.Push(new MyStep1()).Push(new MyStep2()).Trigger();

第一次推送后，推送和触发即可。

Answer 1

一种方法是使用接口通过指定接口作为结果来限制对特定方法的访问。

public interface IStartCar
{
  IDriveCar Start(string key);
}

public interface IDriveCar
{
  IParkCar Drive(string address);
}

public interface IParkCar
{
  IStopCar Park();
}

public interface IStopCar
{
  IParkCar Drive(string address);
  void Stop();
}

public class Car : IStartCar, IDriveCar, IParkCar, IStopCar
{
  public IDriveCar Start(string key);
  public IParkCar Drive(string address);
  public IStopCar Park();
  public IStopCar Park();

  private Car() { }

  public static IStartCar Get()
  {
    var result = new Car();
    return result;
  }
}

现在要获取汽车，您使用 CarFactory 方法Get()，它返回汽车，但您实际上只能访问接口结果。这种模式只允许开发人员将特定的方法串在一起：

var car = Car.Get();
car.Start("key").Drive("address1").Park().Drive("address2").Park().Stop();

Answer 2

几个小时后，我想出了这个设计：

   public interface IBasePipelineRegister<T> where T:BaseResult
    {
       IStagePipeline<T> Push(StepBaseBusiness<T> step);
       List<StepBaseBusiness<T>> Steps { get; set; }
    }


   public interface IBasePipelineTrigger<T> where T:BaseResult
    {
        void Trigger(T result);
    }

   public interface IStagePipeline<T>: IBasePipelineTrigger<T>,IBasePipelineRegister<T> where T:BaseResult 
    {

    }

   public class FlowBasePipeline<TResult> : IBasePipelineRegister<TResult> where TResult : BaseResult,new()
    {
        public List<StepBaseBusiness<TResult>> Steps { get ; set ; }
        private IStagePipeline<TResult> _stagePipeline;
        public BasePipeline()
        {
            this.Steps = new List<StepBaseBusiness<TResult>>();
            this._stagePipeline = new StagePipeline<TResult>(this);
        }
        public IStagePipeline<TResult> Push(StepBaseBusiness<TResult> step)
        {
            Steps.Add(step);
            return _stagePipeline;

        }
    }

如您所见，BasePipeline 只是实现了IBasePipelineRegister，Register 方法提供了新的 StagePipeline 类，该类由当前类和触发器实现组成。

public class StagePipeline<T>: IStagePipeline<T> where T:BaseResult
{
    private readonly IBasePipelineRegister<T> pipelineRegister;
    public List<StepBaseBusiness<T>> Steps { get; set; }

    public StagePipeline(IBasePipelineRegister<T> pipelineRegister)
    {           
        this.pipelineRegister = pipelineRegister;
        Steps = pipelineRegister.Steps;
    }


    public IStagePipeline<T> Push(StepBaseBusiness<T> step)
    {
       return pipelineRegister.Push(step);
    }

    public void Trigger(T result)
    {
        foreach (var step in Steps)
        {
            result = step.Execute(result);
            if (!result.IsSuccess)
            {
                break;
            }

        }
    }


}

现在每个方法都添加一个新功能而不是替换新功能。

var pipeline=new FlowBasePipeline<MyStepResult>();
pipeline.Push(new MyStep1()).Push(new MyStep2()).Trigger();

Answer 3

我用于 api 的方法示例，它固有地以流畅的语法“引导”调用者：

public class Pipeline
{
    readonly List<Action> _steps = new List<Action>();
    
    // only Push is available when Pipeline is initialized
    public PipelineWithSteps Push(Action step)
    {
        _steps.Add(step);
        // or cache this if you want 'Push' repeatable
        return new PipelineWithSteps(this);
    }

    public class PipelineWithSteps
    {
        // not required but often the chained context wants/needs access to the first context
        readonly Pipeline _context;
        
        // api is public but ctor cannot be invoked by external caller
        internal PipelineWithSteps(Pipeline context) => _context = context;
        
        // now Trigger is available only after something was pushed
        public PipelineWithSteps Trigger()
        {
            foreach(var step in _context._steps)
                step();
            Console.WriteLine();
            return this;
        }
        
        // usually I don't repeat an initialization method;
        // this could be done using the 'context' 
        // but would have to be refactored to return the existing 'PipelineWithSteps'
        public PipelineWithSteps Push(Action step)
        {
            _context._steps.Add(step);
            return this;
        }
    }
}

用法：

    var pipeline = new Pipeline();
    pipeline.Push(() => Console.WriteLine("A"))
            .Push(() => Console.WriteLine("B"))
            .Trigger()
            .Push(() => Console.WriteLine("C"))
            .Trigger();

输出：

A
B

A
B
C