A Pipeline Component is a C# class that processes messages flowing through an Art2link ESB Pipeline. Each component receives a message, applies your logic, and returns one or more messages to the next stage of the pipeline.

Art2link ESB handles compilation and deployment automatically. You write the code, save it, and reference it from a Pipeline — no build steps, no restarts, no downtime.

The architecture follows a simple chain: Port → Pipeline → Component(s) → Output. A Pipeline can contain multiple components executed in sequence. Each component operates on the output of the previous one.

Two kinds of work happen inside a component. The obvious one is transformation — reshape the body, enrich it, compress, sign, validate. The second — available only when the component runs on the inbound side of a flow — is classification: the component inspects the message and assigns it a Message Type by setting MessageType on the outgoing PipelineMessage before the bus publishes. See Components can classify the Message Type in the Pipelines article for the full contract; the code-level mechanics live in this reference.

The following classes are provided by the Art2link runtime in the CC.Art2link.Pipelines.Domain.Models.PipelineComponents namespace. Do not redefine them in your component code.

The incoming message passed to your component.

The result returned by your component after processing.

An individual outgoing message.

The abstract base class your component must inherit from. It handles JSON deserialization of the configuration and delegates to your ExecuteAsync implementation.

public abstract class PipelineComponentBase<TConfig>
    : IPipelineComponent where TConfig : new()
{
    public abstract string Name { get; }

    // Called by the engine — deserializes configJson, then delegates below
    public Task<PipelineComponentOutput> ExecuteAsync(
        PipelineComponentInput input,
        string configJson,
        CancellationToken cancellationToken = default) { ... }

    // Implement this method with your logic
    protected abstract Task<PipelineComponentOutput> ExecuteAsync(
        PipelineComponentInput input,
        TConfig config,
        CancellationToken cancellationToken);
}

The configuration class defines all user-editable parameters for your component. Each public property becomes an input field in the Art2link ESB UI when the component is added to a pipeline.

Any type that is JSON-deserializable by System.Text.Json is supported: string, int, bool, double, enum, List<T>, and complex objects.

Assign defaults directly on properties. These values are shown pre-filled in the UI when a user configures your component.

You may use attributes from the System.ComponentModel.DataAnnotations namespace to enforce constraints on configuration values.

using System.ComponentModel.DataAnnotations;

public sealed class MyComponentConfig
{
    [Required]
    public string TargetEndpoint { get; set; } = string.Empty;

    [Range(1, 10)]
    public int MaxRetries { get; set; } = 3;

    public bool IncludeHeaders { get; set; } = true;
}

Configuration values support the {{ }} binding syntax, letting users reference application Variables, application Constants, and message-level promoted properties when configuring a component in the UI:

Each component must override the Name property with a unique identifier. This name is used internally by the pipeline engine to locate and invoke your component.

Components must not throw exceptions. Instead, catch all errors and return a PipelineComponentOutput with Success = false, a descriptive ErrorMessage, and optionally the caught Exception.

When a component returns Success = false, the pipeline stops execution immediately. No subsequent components will be invoked.

protected override Task<PipelineComponentOutput> ExecuteAsync(
    PipelineComponentInput input,
    MyComponentConfig config,
    CancellationToken cancellationToken)
{
    try
    {
        // Your logic here
        return Task.FromResult(new PipelineComponentOutput
        {
            Success = true,
            Messages = [new PipelineMessage { Body = result }]
        });
    }
    catch (Exception ex)
    {
        return Task.FromResult(new PipelineComponentOutput
        {
            Success = false,
            ErrorMessage = ex.Message,
            Exception = ex
        });
    }
}

The shape of the Messages list governs what happens next. Two patterns matter:

Beyond returning a transformed body, a component has two side-effect channels into the surrounding integration. Both are written into the result your component returns.

Both channels are populated at the same time you build the result. Here is an inbound component that produces two outgoing messages, classifies each, and writes one application variable along the way:

protected override Task<PipelineComponentOutput> ExecuteAsync(
    PipelineComponentInput input,
    MyComponentConfig config,
    CancellationToken cancellationToken)
{
    try
    {
        // Your logic here
        return Task.FromResult(new PipelineComponentOutput
        {
            Success = true,
            Variables =
            {
                ["lastProcessedDocument"] = "INV-1001",
            },
            Messages =
            [
                new PipelineMessage
                {
                    Body = acknowledgementResult,
                    MessageType = "AcknowledgementMessageType"
                },
                new PipelineMessage
                {
                    Body = businessResult,
                    MessageType = "BusinessMessageType"
                }
            ]
        });
    }
    catch (Exception ex)
    {
        return Task.FromResult(new PipelineComponentOutput
        {
            Success = false,
            ErrorMessage = ex.Message,
            Exception = ex
        });
    }
}

When you save a component, Art2link ESB compiles and deploys it automatically. There is no manual build step and no restart required. The new version takes effect immediately.