TradeXpert Manual Trading Panel Strategy

Overview

The original TradeXpert MQL5 expert advisor is a manually operated trading panel that exposes a collection of buttons for opening positions, placing pending orders, applying protective stops, and quickly reversing or closing an existing trade. This C# port reproduces the same toolkit inside StockSharp by turning every panel action into a strategy parameter. The strategy itself does not generate trading signals; instead it listens to your manual instructions, executes the requested orders, and supervises protective exits on the incoming candle flow.

Recreated functionality

Market actions. Single-use requests for Buy or Sell market orders using the configured trade volume.
Pending orders. One-shot placement of Buy Limit/Stop and Sell Limit/Stop orders using an absolute price or an offset from the latest candle close.
Protective management. Stop-loss and take-profit levels can be defined either as absolute price levels or as offsets from the recorded entry price. The strategy monitors candle extremes and closes the position with a market order when a protective level is breached.
Manual exit controls. Dedicated parameters replicate the Close and Reverse buttons from the MQL panel, allowing you to close or flip a position on demand.

Strategy logic

The strategy subscribes to the candle type specified by CandleType. The stream is used to determine the most recent closing price for offsets and to detect whether protective levels were crossed.
On every finished candle the strategy:
- Applies the latest TradeVolume to the base class Volume property.
- Handles manual close or reverse requests even if no indicators are formed yet.
- Once market data is confirmed as ready, executes pending entry requests, registers pending orders, and evaluates stop-loss / take-profit triggers.
When a position size changes (new entry, scale in, or reduction), the strategy refreshes the stored entry price so that offset-based stops immediately reflect the latest trade.
Protective logic uses the candle high/low to identify breaches. When a level is crossed, a market order is sent in the opposite direction with the current absolute position size to ensure the position is fully closed.

Parameters

CandleType – candle series used to monitor prices for offsets and risk checks.
TradeVolume – volume applied to every market and pending order (must be positive).
EntryAction – momentary selector with values None, BuyMarket, or SellMarket. Setting a value different from None triggers the corresponding market order exactly once and then resets back to None.
PendingAction – pending order selector (None, BuyLimit, BuyStop, SellLimit, SellStop). The action is consumed after a valid order is registered.
PendingPrice – absolute price for the pending order. Leave at 0 to rely on PendingOffset.
PendingOffset – offset applied to the most recent candle close when PendingPrice is zero. Positive offsets automatically adjust the price above/below the close depending on the selected action.
UseStopLoss / StopLossPrice / StopLossOffset – enable and configure stop-loss protection. Offsets are measured from the stored entry price when the absolute price is not provided.
UseTakeProfit / TakeProfitPrice / TakeProfitOffset – analogous settings for take-profit management.
ClosePositionRequest – set to true to issue an immediate market exit for the entire position. The flag resets to false after the request is processed.
ReversePositionRequest – set to true to flip the current exposure. The strategy closes the existing position and opens an opposite one using ReverseVolume, then resets the flag.
ReverseVolume – volume of the new position established after a reversal. If you need the reverse size to match the existing position, set it equal to the current absolute position.

Usage guidelines

Choose the candle aggregation (CandleType) that matches how you want to measure offsets and risk. The default 1-minute timeframe mirrors the original panel behaviour that reacted to incoming ticks.
Configure TradeVolume and optional protective levels (StopLoss*, TakeProfit*). You can freely switch between absolute levels and offsets; the offsets activate whenever the absolute value is left at zero.
For pending orders, decide whether you prefer a fixed price (PendingPrice) or an offset from the latest close (PendingOffset). The strategy recalculates the price at the moment the order is submitted.
Submit trade instructions by changing EntryAction, PendingAction, ClosePositionRequest, or ReversePositionRequest. Each parameter behaves like a button: once the request is executed the value automatically resets so the action is not repeated on the next candle.
The strategy keeps monitoring price action while a position is open. Whenever a stop-loss or take-profit threshold is crossed the position is closed with a market order; both protective triggers are disabled until the next entry to avoid duplicate orders.

Differences from the original MQL version

The visual panel is replaced with strategy parameters. Every button from the original UI is now exposed as a toggle or selector that can be edited from the StockSharp parameter grid or automation scripts.
Instead of placing stop or limit orders for protection, the strategy closes the position with market orders when the specified price levels are breached. This keeps the implementation compatible with the high-level API and avoids maintaining separate stop orders.
Price offsets use finished candles instead of raw ticks. This keeps behaviour deterministic across backtests and live trading sessions while still delivering intraday responsiveness.

Notes

You can queue multiple instructions within the same candle (for example, request a market buy and immediately request a take-profit offset). The strategy processes them sequentially on the next finished candle.
If you need to reissue the same action, simply select the desired value again; the internal tracking logic detects the change and executes the new request.
When scaling into a position, the stored entry price is updated to the close of the candle that reflects the new size. Adjust the offsets accordingly if you require precise protective distances.

using System; using System.Collections.Generic; using StockSharp.Algo.Indicators; using StockSharp.Algo.Strategies; using StockSharp.BusinessEntities; using StockSharp.Messages; namespace StockSharp.Samples.Strategies; /// <summary> /// TradeXpert Manual Trading Panel strategy. Uses CCI zero-line crossover (period 20). /// </summary> public class TradeXpertManualTradingPanelStrategy : Strategy { private readonly StrategyParam<DataType> _candleType; private readonly StrategyParam<int> _cciPeriod; private decimal? _prevCci; public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; } public int CciPeriod { get => _cciPeriod.Value; set => _cciPeriod.Value = value; } public TradeXpertManualTradingPanelStrategy() { _candleType = Param(nameof(CandleType), TimeSpan.FromHours(1).TimeFrame()).SetDisplay("Candle Type", "Timeframe", "General"); _cciPeriod = Param(nameof(CciPeriod), 20).SetGreaterThanZero().SetDisplay("CCI Period", "CCI lookback", "Indicators"); } public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities() => [(Security, CandleType)]; /// <inheritdoc /> protected override void OnReseted() { base.OnReseted(); _prevCci = null; } protected override void OnStarted2(DateTime time) { base.OnStarted2(time); _prevCci = null; var cci = new CommodityChannelIndex { Length = CciPeriod }; var subscription = SubscribeCandles(CandleType); subscription.Bind(cci, ProcessCandle).Start(); var area = CreateChartArea(); if (area != null) { DrawCandles(area, subscription); DrawOwnTrades(area); } } private void ProcessCandle(ICandleMessage candle, decimal cciVal) { if (candle.State != CandleStates.Finished) return; if (!IsFormedAndOnlineAndAllowTrading()) { _prevCci = cciVal; return; } if (_prevCci == null) { _prevCci = cciVal; return; } if (_prevCci.Value < 0m && cciVal >= 0m && Position <= 0) { if (Position < 0) BuyMarket(); BuyMarket(); } else if (_prevCci.Value > 0m && cciVal <= 0m && Position >= 0) { if (Position > 0) SellMarket(); SellMarket(); } _prevCci = cciVal; } }

import clr clr.AddReference("StockSharp.Messages") clr.AddReference("StockSharp.Algo") clr.AddReference("StockSharp.Algo.Indicators") clr.AddReference("StockSharp.Algo.Strategies") from System import TimeSpan from StockSharp.Messages import DataType, CandleStates from StockSharp.Algo.Indicators import CommodityChannelIndex from StockSharp.Algo.Strategies import Strategy from datatype_extensions import * from indicator_extensions import * class trade_xpert_manual_trading_panel_strategy(Strategy): """CCI zero-line crossover.""" def __init__(self): super(trade_xpert_manual_trading_panel_strategy, self).__init__() self._cci_period = self.Param("CciPeriod", 20).SetGreaterThanZero().SetDisplay("CCI Period", "CCI lookback", "Indicators") self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromHours(1))).SetDisplay("Candle Type", "Timeframe", "General") @property def CandleType(self): return self._candle_type.Value @CandleType.setter def CandleType(self, value): self._candle_type.Value = value def OnReseted(self): super(trade_xpert_manual_trading_panel_strategy, self).OnReseted() self._prev_cci = None def OnStarted2(self, time): super(trade_xpert_manual_trading_panel_strategy, self).OnStarted2(time) self._prev_cci = None cci = CommodityChannelIndex() cci.Length = self._cci_period.Value sub = self.SubscribeCandles(self.CandleType) sub.Bind(cci, self.OnProcess).Start() area = self.CreateChartArea() if area is not None: self.DrawCandles(area, sub) self.DrawOwnTrades(area) def OnProcess(self, candle, cci_val): if candle.State != CandleStates.Finished: return if self._prev_cci is None: self._prev_cci = float(cci_val) return cci_f = float(cci_val) if self._prev_cci < 0 and cci_f >= 0 and self.Position <= 0: if self.Position < 0: self.BuyMarket() self.BuyMarket() elif self._prev_cci > 0 and cci_f <= 0 and self.Position >= 0: if self.Position > 0: self.SellMarket() self.SellMarket() self._prev_cci = cci_f def CreateClone(self): return trade_xpert_manual_trading_panel_strategy()