The contract surface for building indicators: the IIndicator lifecycle, the IIndicatorContext runtime view, the IndicatorBase base class, the declaration attributes, the cadence enums, and the optional render / interaction capability interfaces. Everything here lives in TradeStrike.Pipeline.Indicators.

IIndicator INTERFACE

The lifecycle contract every indicator implements (it extends IDisposable). The runtime calls the hooks; implementations never call them on each other — they communicate through child indicators and the shared bar/series storage. Callbacks are single-threaded per instance: no two hooks fire in parallel for the same indicator.

Lifecycle ordering: OnInit once → OnDataLoaded once (with all historical bars already in storage) → OnBarUpdate per closed/intra-bar event at the Calculate cadence → OnMarketData per live tick (only if ProcessesMarketData) → OnDataSeriesReady when an added series finishes backfill → OnDispose once. Live hooks never fire during backfill.

Properties

Lifecycle & child-tree methods

IIndicatorContext INTERFACE

The runtime view an indicator has of its environment, passed to every lifecycle hook. Single-threaded with respect to the indicator. Do not cache it across threads or persist it past a callback. Many members are default-interface methods so test stubs and foreign hosts compile unchanged.

Series & per-callback metadata

Resources, orderflow & instrument info

Trading hours, rollovers & diagnostics

IndicatorBase BASE CLASS

The class plugin authors derive from. It implements IIndicator, IOrderFlowResolutionAware and IInputSourceAware, and provides empty virtual lifecycle hooks (override only what you need), lazy ContentKey, idempotent Dispose, the parent-owned child tree, and the plot/line registration helpers.

Sma.csusing TradeStrike.Pipeline.Indicators;
using TradeStrike.Pipeline.Plots;
using TradeStrike.Pipeline.Series;

[IndicatorDescription("Simple moving average of the input series.")]
[IndicatorCategory(IndicatorCategory.Trend)]
[IndicatorInput(IndicatorInputKind.Scalar)]
[IndicatorPlot("SMA", IsOverlay = true, Kind = PlotKind.Overlay, Unit = PlotValueUnit.Price)]
public sealed class Sma : IndicatorBase
{
    private readonly Plot _sma = new();

    [IndicatorParameter(DisplayName = "Period", MinValue = 1, MaxValue = 500, Step = 1)]
    public int Period { get; set; } = 14;

    public Sma(IIndicator? parent = null, ISeries<double>? input = null)
        : base(parent, input)
    {
        AddPlot(_sma);
    }

    public override void OnBarUpdate(IIndicatorContext ctx)
    {
        int n = Math.Min(Period, ctx.CurrentBar + 1);
        double sum = 0;
        for (int i = 0; i < n; i++) sum += Input[i];
        _sma.Values[0] = sum / n;
    }
}

Construction

Every subclass exposes one ctor of the shape Xxx(IIndicator? parent = null, ISeries<double>? input = null, /* params */) : base(parent, input). The base ctor stores Input/Bars and, when parent is non-null, registers as a child. The child's own OnInit/OnDataLoaded are deferred to the first dispatch event so the derived ctor body sets Period, plots, etc. before lifecycle math runs.

protected IndicatorBase(IIndicator? parent = null, ISeries<double>? input = null, IBarSeries? bars = null);

Public & protected members

Overridable virtuals

CalculationMode ENUM

Frequency at which the runtime dispatches OnBarUpdate on the primary series. Mirrors NinjaTrader's three modes. Controls only the bar-callback cadence — raw-tick delivery is the separate ProcessesMarketData opt-in.

CalculationCadence STATIC HELPER

The single source of truth for "given a CalculationMode and the current update, should the callback fire?" — shared by the indicator runtime and the strategy runner.

public static bool ShouldFire(CalculationMode mode, bool isClosed, bool closeChanged);
//  OnBarClose    => isClosed
//  OnPriceChange => isClosed || closeChanged
//  OnEachTick    => true

Attributes

Class- and property-level attributes the framework reads by reflection to compute content keys, render the parameter editor, persist values, and route data. All are Inherited = true.

IndicatorParameter (property)

Marks a property as a user-tunable parameter. Constraints are advisory (the editor enforces them; programmatic sets are not clamped).

ParameterEditorKind enum: Auto = 0 (host picks from the CLR type), FilePicker = 1 (path field + Browse), SymbolPicker = 2 (shared instrument picker for a benchmark/comparison symbol).

IndicatorPlot (class, repeatable)

Declares a named plot the indicator produces — one ISeries<T> per plot. An indicator with zero declared plots is refused (no observable output).

Class-level marker & metadata attributes

Enums: IndicatorCategory = Unspecified, Trend, Momentum, Volume, Volatility, OrderFlow, Structure, Custom. IndicatorInputKind = Scalar = 0, Bars = 1, None = 2.

Metadata & identity

Reflection-extracted, per-type cached data driving content keys, the parameter editor, and discovery.

Records: ParameterDescriptor(PropertyInfo Property, string Name, string DisplayName, string Description, string Group, int Order, object? MinValue, object? MaxValue, object? Step, ParameterEditorKind Editor, string FileFilter) with init-only ContentKeyDefault; PlotDescriptor(string Name, string Description, bool IsOverlay) with init-only Semantics.

IParameterContainerProvider — object ParameterContainer { get; }: the live settings instance for a [ParameterContainer] indicator.

PlotSemantics

The machine-readable meaning of a plot's value, so a consumer can interpret RSI = 71.6 vs EMA = 5012 without recognising the indicator. PlotSemantics.Default = everything unspecified.

public sealed record PlotSemantics(
    PlotKind Kind, double? RangeMin, double? RangeMax,
    PlotValueUnit Unit, PlotBullishDirection BullishDirection, string? Reference);
// bool HasRange => RangeMin.HasValue && RangeMax.HasValue;

Input sources

IInputSourceAware / IOrderFlowResolutionAware — backing-store contracts (InputSourceDescriptor InputSource { get; set; } and OrderFlowResolution OrderFlowResolution { get; set; }) that IndicatorBase implements so the editor/codec descriptors are synthesized only for the right indicators.

InputPriceType enum (mirrors NT's price types plus channels): Close = 0, Open, High, Low, Median, Typical, Weighted, OHLC4, Volume, OpenInterest = 9.

InputSourceDescriptor — a serializable value type describing where the scalar Input comes from: a price type, or another indicator's plot (a private configured copy). Its canonical string is a frozen, persisted grammar; structural equality is semantic equality.

Optional capability interfaces

An indicator opts into extra host integration by ALSO implementing one of these alongside IIndicator. The core indicator surface stays minimal — only the indicators that need a capability take the dependency.

Context structs: ChartClickContext(double X, double Y); ChartMouseMoveContext(double X, double Y) with IsInside + Outside; IndicatorContextMenuLocation(int BarIndex, double Price, DateTime Time, double PixelX, double PixelY). CustomRenderLayer enum = BelowBars, AboveBars (default). PanelPlacement enum = PriceOverlay, NewSubpanel.

IIndicatorRenderContext & menu items

The per-frame context passed to the render capability methods. Single-threaded (WPF UI thread); do not cache it across frames.

ToolbarMenuItem hierarchy

A closed record hierarchy (the host pattern-matches the concrete types) reused by both IIndicatorToolbarMenu and IIndicatorContextMenu. Built fresh per open — do not cache.

Helpers

Factory, resolver & logger

Alerts

IndicatorAlert — the payload raised by ctx.Alert(…):

public readonly record struct IndicatorAlert(
    string Id, string Message, DateTime TimeUtc,
    AlertSeverity Severity = AlertSeverity.Info, string? SoundPath = null,
    double RearmSeconds = 0, string? InstrumentId = null);

IIndicatorAlertSink — host seam delivering alerts to the user: void Dispatch(in IndicatorAlert alert). Thread-safe; return promptly.