The Market Analyzer is SabrTrader's spreadsheet-style watchlist: one row per instrument, one column per fact you care about (last price, spread, session volume, an indicator value, your open P&L). A column plugin adds a column to that grid. Put the DLL in the plugin folder and your column shows up in the Columns… dialog, categorized and searchable, and persists across restarts, with no host changes.

What a column plugin is

A column plugin is a small, self-contained set of .NET types that teaches the Market Analyzer how to compute and display one fact per row. You provide two things:

• An immutable definition: the column's identity, header and payload type (IColumnDefinition).
• A per-row value source: a small worker that subscribes to the row's market data (or runs a one-shot backfill) and pushes cell values into the grid (IColumnValueSource).

The host does everything else: discovery, instantiation, workspace persistence, styling, conditional formatting, sorting and totals. You code against SabrTrader.Pipeline.Contracts (the SDK assembly) and never reference the engine.

Why it exists

Watchlists are where traders live. The analyzer ships a standard column set, but the facts a desk needs are open-ended: a venue-specific spread metric, a proprietary signal, a basket P&L, the output of an in-house indicator. Rebuilding the grid, the persistence codec and the conditional-formatting engine for each of those is not practical.

The column contract is an open/closed seam: a column kind is one IColumnDefinition implementation, and the engine, the grid and the workspace format stay as they are. Definitions are value-objects that hold no mutable state, never reference the engine and never depend on a specific data provider, so one definition instance is shared across every row of the panel.

When to build one

The model: definition → context → source

The contract is built from three collaborating roles:

The definition holds no per-row state; that lives in the source it spawns. A source reads only its own data origin: cross-column composition runs through the engine's expression evaluator, never through references between sources. That loose coupling keeps each column kind independent.

Data flow

When a row is added to a panel, the engine calls the definition's CreateSource once for that row, hands the new source an IColumnValueSink via StartAsync, and from then on every value the source publishes flows into that row's cell.

graph TD
  Def["IColumnDefinition
(one per column)"] -->|CreateSource(instrument, context)| Src["IColumnValueSource
(one per row)"]
  Ctx["IColumnContext
(clock, sessions, row feed)"] -.->|injected| Src
  Src -->|StartAsync| Sub["subscribe / backfill"]
  Sub -->|tick / timer / event| Src
  Src -->|sink.Publish(CellValue)| Sink["IColumnValueSink"]
  Sink -->|marshalled onto row actor| Cell["Grid cell
(Initializing / Ready / Error)"]
    

A guided tour

A minimal but complete column, end to end, so the shape is concrete before the detail chapters. It shows the last traded price of each row, read from the row's shared feed.

LastTradeColumn.csusing System;
using System.Threading;
using System.Threading.Tasks;
using SabrTrader.Pipeline.MarketAnalyzer;

namespace MyPlugin.Columns;

// 1) The definition: stateless identity + a per-row source factory.
[MarketAnalyzerColumn("Last trade",
    Category    = "My plugin",
    Description = "Last traded price of the row's instrument.")]
public sealed class LastTradeColumn : IColumnDefinition
{
    public string Id => "myplugin.last-trade";          // stable and globally unique
    public string Header => "Last";
    public ColumnDataType DataType => ColumnDataType.Price;

    public IColumnValueSource CreateSource(InstrumentRef instrument, IColumnContext context)
        => new LastTradeSource(context);
}

// 2) The source: one per row. Listens to the row's quote, publishes on every Last change.
internal sealed class LastTradeSource : IColumnValueSource
{
    private readonly IColumnContext _context;
    private IDisposable? _subscription;

    public LastTradeSource(IColumnContext context) => _context = context;

    public Task StartAsync(IColumnValueSink sink, CancellationToken cancellationToken)
    {
        IInstrumentFeed? feed = _context.GetService<IInstrumentFeed>();
        if (feed is null)
        {
            sink.Publish(CellValue.Error("No market data for this row."));
            return Task.CompletedTask;
        }

        sink.Publish(CellValue.Initializing);
        // Runs on the feed thread; a known quote is replayed to the handler at once.
        _subscription = feed.OnQuote(change =>
        {
            if ((change.Changed & RowQuoteFields.Last) != 0 && change.Quote.HasLast)
                sink.Publish(CellValue.Ready(change.Quote.Last));   // safe from any thread
        });

        return Task.CompletedTask;
    }

    public ValueTask DisposeAsync()
    {
        _subscription?.Dispose();
        return ValueTask.CompletedTask;
    }
}

That is the entire plugin. The host finds the public IColumnDefinition, lists it in the Columns dialog under the [MarketAnalyzerColumn] name, persists the user's choice and styles the cell. The next three chapters unpack each piece.

The contract surface

Everything in this chapter lives in the SabrTrader.Pipeline.MarketAnalyzer namespace inside the SabrTrader.Pipeline.Contracts SDK assembly: