Added support for input-only pipelines

Author: Visual-Vincent

FluentPipelines/IPipelineBuilder.cs

@@ -36,5 +36,19 @@ public interface IPipelineBuilder<TInput, TOutput>
         /// <param name="step">The next step of the pipeline, processing the data from the previous step.</param>
         /// <returns>A builder that allows you to continue building the rest of the pipeline.</returns>
         IPipelineBuilder<TInput, TNext> Then<TNext>(IPipelineStep<TOutput, TNext> step);
+
+        /// <summary>
+        /// Defines the final step of the pipeline, returning no output data.
+        /// </summary>
+        /// <param name="action">A function acting as the next step of the pipeline, processing the data from the previous step and completing the pipeline.</param>
+        /// <returns>A builder that allows you to build the pipeline.</returns>
+        IInPipelineBuilder<TInput> Then(InPipelineStepDelegate<TOutput> action);
+
+        /// <summary>
+        /// Defines the final step of the pipeline, returning no output data.
+        /// </summary>
+        /// <param name="step">The next step of the pipeline, processing the data from the previous step and completing the pipeline.</param>
+        /// <returns>A builder that allows you to build the pipeline.</returns>
+        IInPipelineBuilder<TInput> Then(IInPipelineStep<TOutput> step);
     }
 }

FluentPipelines/Input/IInPipeline.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// Defines methods for a pipeline that takes <typeparamref name="TInput"/> as input, and has no output.
+    /// </summary>
+    /// <typeparam name="TInput">The type of data used as input to the pipeline.</typeparam>
+    public interface IInPipeline<TInput>
+    {
+        /// <summary>
+        /// Runs the pipeline.
+        /// </summary>
+        /// <param name="input">The input data.</param>
+        void Run(TInput input);
+    }
+}

FluentPipelines/Input/IInPipelineBuilder.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// Defines methods for a builder that constructs pipelines with input data and no output data.
+    /// </summary>
+    /// <typeparam name="TInput">The type of data used as input to the pipeline.</typeparam>
+    public interface IInPipelineBuilder<TInput>
+    {
+        /// <summary>
+        /// Compiles all steps and builds a runnable pipeline.
+        /// </summary>
+        /// <returns>The resulting pipeline.</returns>
+        IInPipeline<TInput> Build();
+    }
+}

FluentPipelines/Input/IInPipelineStep.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// Defines methods for a step in a pipeline with input data and no output data.
+    /// </summary>
+    /// <typeparam name="TInput">The type of data used as input to the step.</typeparam>
+    public interface IInPipelineStep<TInput>
+    {
+        /// <summary>
+        /// Executes the step.
+        /// </summary>
+        /// <param name="input">The input data to process.</param>
+        void Run(TInput input);
+    }
+}

FluentPipelines/Input/InFunctionStep.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// A pipeline step that executes a delegate method.
+    /// </summary>
+    /// <typeparam name="TInput">The type of data used as input to the step.</typeparam>
+    public class InFunctionStep<TInput> : IInPipelineStep<TInput>
+    {
+        private readonly InPipelineStepDelegate<TInput> function;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InFunctionStep{TInput}"/> class.
+        /// </summary>
+        /// <param name="function">The delegate method to execute.</param>
+        public InFunctionStep(InPipelineStepDelegate<TInput> function)
+        {
+            this.function = function ?? throw new ArgumentNullException(nameof(function));
+        }
+
+        /// <inheritdoc/>
+        public void Run(TInput input)
+        {
+            function(input);
+        }
+    }
+}

FluentPipelines/Input/InPipeline.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// A pipeline that takes <typeparamref name="TInput"/> as input, and has no output.
+    /// </summary>
+    /// <typeparam name="TInput">The type of data used as input to the pipeline.</typeparam>
+    public sealed class InPipeline<TInput> : IInPipeline<TInput>
+    {
+        private readonly PipelineStep[] steps;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InPipeline{TInput}"/> class.
+        /// </summary>
+        /// <param name="steps">
+        /// The steps to be executed as part of the pipeline.
+        /// It is important that the first step takes <typeparamref name="TInput"/> as input.
+        /// </param>
+        public InPipeline(IEnumerable<PipelineStep> steps)
+        {
+            if(steps is null)
+                throw new ArgumentNullException(nameof(steps));
+
+            if(!steps.Any())
+                throw new ArgumentException("No steps specified", nameof(steps));
+
+            this.steps = steps.ToArray();
+        }
+
+        /// <inheritdoc/>
+        public void Run(TInput input)
+        {
+            steps.Execute(input);
+        }
+    }
+
+    /// <summary>
+    /// A static class containing helper methods for <see cref="InPipeline{TInput}"/>.
+    /// </summary>
+    public static class InputPipeline
+    {
+        /// <summary>
+        /// Creates an <see cref="InPipeline{TInput}"/> from a <see cref="InPipelineBuilder{TInput}"/>.
+        /// </summary>
+        /// <typeparam name="TInput">The type of data used as input to the pipeline.</typeparam>
+        /// <param name="builder">The builder containing the steps to be executed as part of the pipeline.</param>
+        /// <returns>The resulting pipeline.</returns>
+        public static InPipeline<TInput> CreateFrom<TInput>(InPipelineBuilder<TInput> builder)
+        {
+            return new InPipeline<TInput>(builder.Steps);
+        }
+    }
+}

FluentPipelines/Input/InPipelineBuilder.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// A builder that builds a pipeline with input data and no output data.
+    /// </summary>
+    /// <typeparam name="TInput">The type of data used as input to the pipeline.</typeparam>
+    public class InPipelineBuilder<TInput> : IInPipelineBuilder<TInput>
+    {
+        /// <summary>
+        /// Gets the collection of steps added to the builder, which will be used to construct the pipeline.
+        /// <para><b>IMPORTANT:</b> The first step must take <typeparamref name="TInput"/> as input, otherwise the built-in pipeline types will not work.</para>
+        /// </summary>
+        protected internal List<PipelineStep> Steps { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InPipelineBuilder{TInput}"/> class.
+        /// </summary>
+        /// <param name="steps">
+        /// The collection of steps to add to the builder, which will be used to construct the pipeline.
+        /// <para><b>IMPORTANT:</b> The first step must take <typeparamref name="TInput"/> as input, otherwise the built-in pipeline types will not work.</para>
+        /// <para><b>IMPORTANT:</b> <paramref name="steps"/> is taken by reference! The list is NOT copied!</para>
+        /// </param>
+        protected internal InPipelineBuilder(List<PipelineStep> steps)
+        {
+            Steps = steps ?? throw new ArgumentNullException(nameof(steps));
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InPipelineBuilder{TInput}"/> class.
+        /// </summary>
+        /// <param name="firstStep">
+        /// The first step of the pipeline, processing the input data.
+        /// <para><b>IMPORTANT:</b> This must take <typeparamref name="TInput"/> as input, otherwise the built-in pipeline types will not work.</para>
+        /// </param>
+        public InPipelineBuilder(PipelineStep firstStep)
+        {
+            if(firstStep is null)
+                throw new ArgumentNullException(nameof(firstStep));
+
+            Steps = new List<PipelineStep>() { firstStep };
+        }
+
+        /// <inheritdoc/>
+        public virtual IInPipeline<TInput> Build()
+        {
+            return new InPipeline<TInput>(Steps);
+        }
+    }
+}

FluentPipelines/Input/InPipelineStep.cs

@@ -0,0 +1,53 @@
+using System;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// A pipeline step with input data and no output data.
+    /// </summary>
+    /// <typeparam name="TInput">The type of data used as input to the step.</typeparam>
+    public sealed class InPipelineStep<TInput> : InPipelineStep
+    {
+        private readonly IInPipelineStep<TInput> step;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="InPipelineStep{TInput}"/> class.
+        /// </summary>
+        /// <param name="step">The base step to create this generic step from.</param>
+        public InPipelineStep(IInPipelineStep<TInput> step)
+        {
+            this.step = step ?? throw new ArgumentNullException(nameof(step));
+        }
+
+        internal override void Run(object input)
+        {
+            step.Run((TInput)input);
+        }
+    }
+
+    /// <summary>
+    /// The base class for generic, typeless pipeline steps. Also contains helper methods to create strongly typed generic steps.
+    /// </summary>
+    public class InPipelineStep
+    {
+        /// <summary>
+        /// Creates a <see cref="InPipelineStep{TInput}"/>.
+        /// </summary>
+        /// <typeparam name="TInput">The type of data used as input to the step.</typeparam>
+        /// <param name="step">The base step to create the generic step from.</param>
+        /// <returns>A generic pipeline step.</returns>
+        public static InPipelineStep<TInput> Create<TInput>(IInPipelineStep<TInput> step)
+        {
+            return new InPipelineStep<TInput>(step);
+        }
+
+        internal InPipelineStep()
+        {
+        }
+
+        internal virtual void Run(object input)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

FluentPipelines/Input/InPipelineStepDelegate.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace FluentPipelines
+{
+    /// <summary>
+    /// A delegate method representing a pipeline step.
+    /// </summary>
+    /// <typeparam name="TInput">The type of data used as input to the step.</typeparam>
+    /// <param name="input">The input data to process.</param>
+    public delegate void InPipelineStepDelegate<in TInput>(TInput input);
+}

FluentPipelines/PipelineBuilder.cs

@@ -68,5 +68,30 @@ public virtual IPipelineBuilder<TInput, TNext> Then<TNext>(IPipelineStep<TOutput
 
             return new PipelineBuilder<TInput, TNext>(Steps);
         }
+
+        /// <inheritdoc/>
+        public IInPipelineBuilder<TInput> Then(InPipelineStepDelegate<TOutput> action)
+        {
+            if(action is null)
+                throw new ArgumentNullException(nameof(action));
+
+            return Then(new InFunctionStep<TOutput>(action));
+        }
+
+        /// <inheritdoc/>
+        public IInPipelineBuilder<TInput> Then(IInPipelineStep<TOutput> step)
+        {
+            if(step is null)
+                throw new ArgumentNullException(nameof(step));
+
+            Steps.Add(new PipelineStep<TOutput, object>(
+                new FunctionStep<TOutput, object>(input => {
+                    step.Run(input);
+                    return null;
+                })
+            ));
+
+            return new InPipelineBuilder<TInput>(Steps);
+        }
     }
 }