DecomposedStrategy

DecomposedStrategy

public DecomposedStrategy()

decomposedStrategy = DecomposedStrategy()

Initializes a new instance DecomposedStrategy.

DecomposedStrategy

public DecomposedStrategy(IPnLManager pnlManager, IStatisticManager stats)

decomposedStrategy = DecomposedStrategy(pnlManager, stats)

Initializes a new instance DecomposedStrategy.

pnlManager

PnL manager.

stats

Statistic manager.

CancelOrdersWhenStopping

public bool CancelOrdersWhenStopping { get; set; }

value = decomposedStrategy.CancelOrdersWhenStopping
decomposedStrategy.CancelOrdersWhenStopping = value

Cancel active orders when strategy is stopping.

CommentMode

public StrategyCommentModes CommentMode { get; set; }

value = decomposedStrategy.CommentMode
decomposedStrategy.CommentMode = value

Comment mode.

Commission

public decimal? Commission { get; }

value = decomposedStrategy.Commission

Total accumulated commission (from orders + trades).

Connector

public IConnector Connector { get; set; }

value = decomposedStrategy.Connector
decomposedStrategy.Connector = value

Connector (via interface for testability).

Engine

public StrategyEngine Engine { get; }

value = decomposedStrategy.Engine

State machine + message routing.

ErrorState

public LogLevels ErrorState { get; set; }

value = decomposedStrategy.ErrorState
decomposedStrategy.ErrorState = value

Error state.

IsFormed

public virtual bool IsFormed { get; }

value = decomposedStrategy.IsFormed

Whether the strategy is formed.

IsOnline

public bool IsOnline { get; private set; }

value = decomposedStrategy.IsOnline
decomposedStrategy.IsOnline = value

Is online.

Latency

public TimeSpan? Latency { get; set; }

value = decomposedStrategy.Latency
decomposedStrategy.Latency = value

Latency.

Orders

public OrderPipeline Orders { get; }

value = decomposedStrategy.Orders

Order tracking and processing.

OrdersKeepTime

public TimeSpan OrdersKeepTime { get; set; }

value = decomposedStrategy.OrdersKeepTime
decomposedStrategy.OrdersKeepTime = value

The time for storing orders in memory.

PnLManager

public IPnLManager PnLManager { get; }

value = decomposedStrategy.PnLManager

PnL manager.

Portfolio

public Portfolio Portfolio { get; set; }

value = decomposedStrategy.Portfolio
decomposedStrategy.Portfolio = value

Portfolio.

PortfolioLookup

public Subscription PortfolioLookup { get; }

value = decomposedStrategy.PortfolioLookup

Portfolio lookup subscription.

Position

public decimal Position { get; set; }

value = decomposedStrategy.Position
decomposedStrategy.Position = value

Current position (primary security).

Positions

public PositionPipeline Positions { get; }

value = decomposedStrategy.Positions

Position event handling.

PositionsList

public IReadOnlyDictionary<ValueTuple<SecurityId, string>, decimal> PositionsList { get; }

value = decomposedStrategy.PositionsList

All tracked positions.

ProcessState

public ProcessStates ProcessState { get; }

value = decomposedStrategy.ProcessState

Current process state.

RiskManager

public IRiskManager RiskManager { get; set; }

value = decomposedStrategy.RiskManager
decomposedStrategy.RiskManager = value

Risk manager.

Security

public Security Security { get; set; }

value = decomposedStrategy.Security
decomposedStrategy.Security = value

Security.

Slippage

public decimal? Slippage { get; }

value = decomposedStrategy.Slippage

Total accumulated slippage.

StartedTime

public DateTime StartedTime { get; private set; }

value = decomposedStrategy.StartedTime
decomposedStrategy.StartedTime = value

Strategy start time.

StatisticManager

public IStatisticManager StatisticManager { get; }

value = decomposedStrategy.StatisticManager

Statistics manager.

Subscriptions

public SubscriptionRegistry Subscriptions { get; }

value = decomposedStrategy.Subscriptions

Subscription management.

TotalWorkingTime

public TimeSpan TotalWorkingTime { get; private set; }

value = decomposedStrategy.TotalWorkingTime
decomposedStrategy.TotalWorkingTime = value

Total working time.

Trades

public TradePipeline Trades { get; }

value = decomposedStrategy.Trades

Trade processing and PnL.

TradingMode

public StrategyTradingModes TradingMode { get; set; }

value = decomposedStrategy.TradingMode
decomposedStrategy.TradingMode = value

Trading mode.

UnsubscribeOnStop

public bool UnsubscribeOnStop { get; set; }

value = decomposedStrategy.UnsubscribeOnStop
decomposedStrategy.UnsubscribeOnStop = value

Unsubscribe from market data when strategy is stopping.

Volume

public decimal Volume { get; set; }

value = decomposedStrategy.Volume
decomposedStrategy.Volume = value

Default order volume.

WaitAllTrades

public bool WaitAllTrades { get; set; }

value = decomposedStrategy.WaitAllTrades
decomposedStrategy.WaitAllTrades = value

Wait for all trades.

BuyLimit

public Order BuyLimit(decimal price, decimal? volume)

result = decomposedStrategy.BuyLimit(price, volume)

Buy at limit price.

BuyMarket

public Order BuyMarket(decimal? volume)

result = decomposedStrategy.BuyMarket(volume)

Buy at market price.

CanAttach

protected virtual bool CanAttach(Order order)

result = decomposedStrategy.CanAttach(order)

Whether the order can be attached (tracked) by this strategy.

order

Order to check.

Returns: if the order belongs to this strategy.

CancelActiveOrders

public void CancelActiveOrders()

decomposedStrategy.CancelActiveOrders()

Cancel all active orders.

CancelOrder

public void CancelOrder(Order order)

decomposedStrategy.CancelOrder(order)

Cancel an order via the connector.

CanTrade

protected virtual bool CanTrade(Security security, Portfolio portfolio, Sides side, decimal volume, string noTradeReason)

result = decomposedStrategy.CanTrade(security, portfolio, side, volume, noTradeReason)

Check if can trade with order information.

security

Security to trade.

portfolio

Portfolio to trade.

side

Order side.

volume

Order volume.

noTradeReason

Reason why trading is not allowed.

Returns: True if trading is allowed.

ClosePosition

public Order ClosePosition()

result = decomposedStrategy.ClosePosition()

Close current position.

CreateOrder

public Order CreateOrder(Sides side, decimal price, decimal? volume)

result = decomposedStrategy.CreateOrder(side, price, volume)

Create an initialized order object.

side

Order side.

price

Price. 0 for market order.

volume

Volume. If null, Volume is used.

Returns: Order.

EditOrder

public void EditOrder(Order order, Order changes)

decomposedStrategy.EditOrder(order, changes)

Edit an order via the connector.

order

Original order.

changes

Order changes.

GetPositionValue

public decimal GetPositionValue(Security sec, Portfolio pf)

result = decomposedStrategy.GetPositionValue(sec, pf)

Get position value for specific security and portfolio.

OnCurrentPriceUpdated

protected virtual void OnCurrentPriceUpdated(SecurityId secId, decimal price, DateTime serverTime, DateTime localTime)

decomposedStrategy.OnCurrentPriceUpdated(secId, price, serverTime, localTime)

Called when current price updated from market data.

OnError

protected virtual void OnError(Exception error)

decomposedStrategy.OnError(error)

Processing of error, occurred as result of strategy operation.

error

Error.

OnNewMessage

public ValueTask OnNewMessage(Message msg, CancellationToken ct)

result = decomposedStrategy.OnNewMessage(msg, ct)

Handle new outgoing message from connector.

OnNewMyTrade

protected virtual void OnNewMyTrade(MyTrade trade)

decomposedStrategy.OnNewMyTrade(trade)

Called when new trade received.

trade

New trade.

OnNewPosition

protected virtual void OnNewPosition(Position position)

decomposedStrategy.OnNewPosition(position)

Called when new position appears.

position

New position.

OnOrderCancelFailReceived

public void OnOrderCancelFailReceived(Subscription sub, OrderFail fail)

decomposedStrategy.OnOrderCancelFailReceived(sub, fail)

Handle order cancellation failure from connector.

OnOrderChanged

protected virtual void OnOrderChanged(Order order)

decomposedStrategy.OnOrderChanged(order)

Called when order state changed.

order

Changed order.

OnOrderEditFailReceived

public void OnOrderEditFailReceived(Subscription sub, OrderFail fail)

decomposedStrategy.OnOrderEditFailReceived(sub, fail)

Handle order edit failure from connector.

OnOrderReceived

public void OnOrderReceived(Subscription sub, Order order)

decomposedStrategy.OnOrderReceived(sub, order)

Handle order received from connector.

OnOrderRegistered

protected virtual void OnOrderRegistered(Order order)

decomposedStrategy.OnOrderRegistered(order)

Called when order registered (transitioned from Pending to Active/Done).

order

Registered order.

OnOrderRegisterFailed

protected virtual void OnOrderRegisterFailed(OrderFail fail)

decomposedStrategy.OnOrderRegisterFailed(fail)

Called when order registration fails.

fail

Order failure info.

OnOrderRegisterFailReceived

public void OnOrderRegisterFailReceived(Subscription sub, OrderFail fail)

decomposedStrategy.OnOrderRegisterFailReceived(sub, fail)

Handle order registration failure from connector.

OnPositionChanged

protected virtual void OnPositionChanged(Position position)

decomposedStrategy.OnPositionChanged(position)

Called when position changes.

position

Changed position.

OnPositionReceived

public void OnPositionReceived(Subscription sub, Position pos)

decomposedStrategy.OnPositionReceived(sub, pos)

Handle position received from connector.

OnStateChanged

protected virtual void OnStateChanged(ProcessStates state)

decomposedStrategy.OnStateChanged(state)

Called when process state changes.

state

New state.

OnTradeReceived

public void OnTradeReceived(Subscription sub, MyTrade trade)

decomposedStrategy.OnTradeReceived(sub, trade)

Handle trade received from connector.

RegisterOrder

public void RegisterOrder(Order order)

decomposedStrategy.RegisterOrder(order)

Register an order via the connector.

ReRegisterOrder

public void ReRegisterOrder(Order oldOrder, Order newOrder)

decomposedStrategy.ReRegisterOrder(oldOrder, newOrder)

Re-register (cancel + register new) an order via the connector.

oldOrder

Order to cancel.

newOrder

New order to register.

Reset

public void Reset()

decomposedStrategy.Reset()

Reset all state (orders, trades, positions, PnL, subscriptions).

SellLimit

public Order SellLimit(decimal price, decimal? volume)

result = decomposedStrategy.SellLimit(price, volume)

Sell at limit price.

SellMarket

public Order SellMarket(decimal? volume)

result = decomposedStrategy.SellMarket(volume)

Sell at market price.

Start

public void Start()

decomposedStrategy.Start()

Start the strategy.

StartAsync

public ValueTask StartAsync(CancellationToken cancellationToken)

result = decomposedStrategy.StartAsync(cancellationToken)

Start the strategy.

StartProtection

public void StartProtection(Unit takeProfit, Unit stopLoss, bool isStopTrailing, TimeSpan? takeTimeout, TimeSpan? stopTimeout, bool useMarketOrders, bool isLocalStop)

decomposedStrategy.StartProtection(takeProfit, stopLoss, isStopTrailing, takeTimeout, stopTimeout, useMarketOrders, isLocalStop)

Start position protection.

takeProfit

Take offset.

stopLoss

Stop offset.

isStopTrailing

Whether to use a trailing technique.

takeTimeout

Time limit. If protection has not worked by this time, the position will be closed on the market.

stopTimeout

Time limit. If protection has not worked by this time, the position will be closed on the market.

useMarketOrders

Whether to use market orders.

isLocalStop

Force local stop processing regardless of adapter capabilities.

Stop

public void Stop()

decomposedStrategy.Stop()

Stop the strategy.

StopAsync

public ValueTask StopAsync(CancellationToken cancellationToken)

result = decomposedStrategy.StopAsync(cancellationToken)

Stop the strategy.

StopAsync

public ValueTask StopAsync(Exception error, CancellationToken cancellationToken)

result = decomposedStrategy.StopAsync(error, cancellationToken)

Stop the strategy with error.

error

The error that caused the stop.

cancellationToken

Cancellation token.

BoardReceived

public event Action<Subscription, ExchangeBoard> BoardReceived

decomposedStrategy.BoardReceived += handler

Board value received.

CandleReceived

public event Action<Subscription, ICandleMessage> CandleReceived

decomposedStrategy.CandleReceived += handler

Candle value received.

CommissionChanged

public event Action CommissionChanged

decomposedStrategy.CommissionChanged += handler

Commission changed event.

ConnectorChanged

public event Action ConnectorChanged

decomposedStrategy.ConnectorChanged += handler

Connector changed event.

DataTypeReceived

public event Action<Subscription, DataType> DataTypeReceived

decomposedStrategy.DataTypeReceived += handler

Data type value received.

Error

public event Action<Exception> Error

decomposedStrategy.Error += handler

Error event.

IsOnlineChanged

public event Action<DecomposedStrategy> IsOnlineChanged

decomposedStrategy.IsOnlineChanged += handler

Online state changed.

LatencyChanged

public event Action LatencyChanged

decomposedStrategy.LatencyChanged += handler

Latency changed event.

Level1Received

public event Action<Subscription, Level1ChangeMessage> Level1Received

decomposedStrategy.Level1Received += handler

Level1 value received.

NewsReceived

public event Action<Subscription, News> NewsReceived

decomposedStrategy.NewsReceived += handler

News value received.

OrderBookReceived

public event Action<Subscription, IOrderBookMessage> OrderBookReceived

decomposedStrategy.OrderBookReceived += handler

Order book value received.

OrderCancelFailed

public event Action<OrderFail> OrderCancelFailed

decomposedStrategy.OrderCancelFailed += handler

Order cancellation failed.

OrderCancelFailReceived

public event Action<Subscription, OrderFail> OrderCancelFailReceived

decomposedStrategy.OrderCancelFailReceived += handler

Order cancel failure.

OrderCanceling

public event Action<Order> OrderCanceling

decomposedStrategy.OrderCanceling += handler

Order is about to be canceled.

OrderEdited

public event Action<long, Order> OrderEdited

decomposedStrategy.OrderEdited += handler

Order edited.

OrderEditFailed

public event Action<long, OrderFail> OrderEditFailed

decomposedStrategy.OrderEditFailed += handler

Order edit failed.

OrderEditFailReceived

public event Action<Subscription, OrderFail> OrderEditFailReceived

decomposedStrategy.OrderEditFailReceived += handler

Order edit failure.

OrderLogReceived

public event Action<Subscription, IOrderLogMessage> OrderLogReceived

decomposedStrategy.OrderLogReceived += handler

Order log value received.

OrderReceived

public event Action<Subscription, Order> OrderReceived

decomposedStrategy.OrderReceived += handler

Order value received.

OrderRegisterFailed

public event Action<OrderFail> OrderRegisterFailed

decomposedStrategy.OrderRegisterFailed += handler

Order registration failed.

OrderRegisterFailReceived

public event Action<Subscription, OrderFail> OrderRegisterFailReceived

decomposedStrategy.OrderRegisterFailReceived += handler

Order registration failure.

OrderRegistering

public event Action<Order> OrderRegistering

decomposedStrategy.OrderRegistering += handler

Order is about to be registered.

OrderReRegistering

public event Action<Order, Order> OrderReRegistering

decomposedStrategy.OrderReRegistering += handler

Order is about to be re-registered.

OwnTradeReceived

public event Action<Subscription, MyTrade> OwnTradeReceived

decomposedStrategy.OwnTradeReceived += handler

Own trade value received.

ParametersChanged

public event Action ParametersChanged

decomposedStrategy.ParametersChanged += handler

Strategy parameters changed event.

PnLChanged

public event Action PnLChanged

decomposedStrategy.PnLChanged += handler

PnL changed event.

PnLReceived

public event Action<Subscription> PnLReceived

decomposedStrategy.PnLReceived += handler

PnL received event.

PnLReceived2

public event Action<Subscription, Portfolio, DateTime, decimal, decimal?, decimal?> PnLReceived2

decomposedStrategy.PnLReceived2 += handler

PnL received event.

PortfolioReceived

public event Action<Subscription, Portfolio> PortfolioReceived

decomposedStrategy.PortfolioReceived += handler

Portfolio value received.

PositionChanged

public event Action PositionChanged

decomposedStrategy.PositionChanged += handler

Position changed.

PositionReceived

public event Action<Subscription, Position> PositionReceived

decomposedStrategy.PositionReceived += handler

Position value received.

PropertyChanged

public event PropertyChangedEventHandler PropertyChanged

decomposedStrategy.PropertyChanged += handler

The diagram element properties value change event.

Reseted

public event Action Reseted

decomposedStrategy.Reseted += handler

Strategy reset event.

SecurityReceived

public event Action<Subscription, Security> SecurityReceived

decomposedStrategy.SecurityReceived += handler

Security value received.

SlippageChanged

public event Action SlippageChanged

decomposedStrategy.SlippageChanged += handler

Slippage changed event.

SubscriptionFailed

public event Action<Subscription, Exception, bool> SubscriptionFailed

decomposedStrategy.SubscriptionFailed += handler

Subscription failed.

SubscriptionOnline

public event Action<Subscription> SubscriptionOnline

decomposedStrategy.SubscriptionOnline += handler

Subscription is online.

SubscriptionReceived

public event Action<Subscription, object> SubscriptionReceived

decomposedStrategy.SubscriptionReceived += handler

Subscription value received.

SubscriptionStarted

public event Action<Subscription> SubscriptionStarted

decomposedStrategy.SubscriptionStarted += handler

Subscription is started.

SubscriptionStopped

public event Action<Subscription, Exception> SubscriptionStopped

decomposedStrategy.SubscriptionStopped += handler

Subscription is stopped.

TickTradeReceived

public event Action<Subscription, ITickTradeMessage> TickTradeReceived

decomposedStrategy.TickTradeReceived += handler

Tick trade value received.