Y a-t-il un modèle de conception pour une entrée transmise à N méthodes qui renvoient chacune l'entrée de la méthode suivante

Si j'ai bien compris votre explication correctement, vous pouvez utiliser des délégués pour surmonter votre problème. L'un des points importants sur les délégués est qu'elles peuvent être chaînées ensemble afin que vous puissiez appeler n'importe quel nombre de méthodes dans un seul événement.

Chaque processeur transformant une entrée spécifique en une sortie spécifique. Par conséquent, la mise en œuvre du processeur ne devrait connaître que deux types.

public interface IDataInput { }
public interface IDataStep1 { }
public interface IDataStep2 { }
public interface IDataStep3 { }
public interface IDataStepN { }
public interface IDataOutput { }

public interface IStepProcessor<TInput, TOutput>
{
    TOutput Process(TInput input);
}

public delegate TOutput Conveyor<TInput, TOutput>(TInput input);

public class Factory
{
    private readonly IStepProcessor<IDataInput, IDataStep1> m_Step1;
    private readonly IStepProcessor<IDataStep1, IDataStep2> m_Task2;
    private readonly IStepProcessor<IDataStep2, IDataStep3> m_Task3;
    private readonly IStepProcessor<IDataStep3, IDataStepN> m_TaskN;
    private readonly IStepProcessor<IDataStepN, IDataOutput> m_FinalTask;

    public Factory(
        IStepProcessor<IDataInput, IDataStep1> task1,
        IStepProcessor<IDataStep1, IDataStep2> task2,
        IStepProcessor<IDataStep2, IDataStep3> task3,
        IStepProcessor<IDataStep3, IDataStepN> taskN,
        IStepProcessor<IDataStepN, IDataOutput> finalTask
        )
    {
        m_Step1 = task1;
        m_Task2 = task2;
        m_Task3 = task3;
        m_TaskN = taskN;
        m_FinalTask = finalTask;
    }
    public Conveyor<IDataInput, IDataOutput> BuildConveyor()
    {
        return (input) =>
        {
            return m_FinalTask.Process(
                m_TaskN.Process(
                    m_Task3.Process(
                        m_Task2.Process(
                            m_Step1.Process(input)))));
        };
    }
}


public class Client
{
    private readonly Conveyor<IDataInput, IDataOutput> m_Conveyor;

    public Client(Conveyor<IDataInput, IDataOutput> conveyor)
    {
        m_Conveyor = conveyor;
    }

    public void DealWithInputAfterTransformingIt(IDataInput input)
    {
        var output = m_Conveyor(input);
        Console.Write($"Mind your business here {typeof(IDataOutput).IsAssignableFrom(output.GetType())}");
    }
}

public class Program {

    public void StartingPoint(IServiceProvider serviceProvider)
    {
        ISomeDIContainer container = CreateDI();
        container.Register<IStepProcessor<IDataInput, IDataStep1>, Step1Imp>();
        container.Register<IStepProcessor<IDataStep1, IDataStep2>, Step2Imp>();
        container.Register<IStepProcessor<IDataStep2, IDataStep3>, Step3Imp>();
        container.Register<IStepProcessor<IDataStep3, IDataStepN>, StepNImp>();
        container.Register<IStepProcessor<IDataStepN, IDataOutput>, StepOImp>();

        container.Register<Factory>();

        Factory factory = container.Resolve<Factory>();
        var conveyor = factory.BuildConveyor();
        var client = new Client(conveyor);
    }
}

Vous pouvez essayer une approche de décorateur comme ceci: xxx

L'utilisation serait quelque chose comme ci-dessous: xxx

la sortie de la sortie de Cet exemple est: xxx

La classe de processeur abstrait fournit une méthode de modèle que vous pouvez implémenter dans des sous-classes. Donc, chaque classe ProcessorX définit uniquement myLogic (ichainOutput d'entrée)

Les processeurs s'étendent pour appliquer la préservation du temps de compilation de l'ordre du processeur. Il est donc impossible de construire une chaîne où le processor vient avant le processora. Il est possible de construire une chaîne qui omet des processeurs comme dans l'exemple ci-dessus.

L'exemple que je fournis ici ne répond pas à la production finale, ce que je sais est l'une de vos principales préoccupations. Pour faire face à la question, je préférerais construire une classe de mappage pour convertir ichainOutput au format final (je ne connais pas la structure réelle de vos données, alors cela n'est peut-être pas possible).

Dans certains de mes cas, il serait logique d'avoir la sortie d'un processeur être l'entrée pour plusieurs autres processeurs

Utilisation de ce modèle Il serait également possible de construire un «arbre» ​​du processeur plutôt qu'une chaîne, en permettant à la classe du processeur d'avoir une liste des prochaines étapes. Votre usage deviendrait alors quelque chose comme ceci: xxx

J'espère que cela peut vous aider.