中文 ZH
在 GitHub 上查看

YTG ADX Level Cross 策略

该策略将 Yuriy Tokman 的 _ADX.mq5 专家顾问转换为 StockSharp 高级 API。它监控平均趋向指数（ADX），当 +DI 或 -DI 线突破可配置阈值时触发交易。策略始终保持单笔持仓，并自动设置以点数表示的止盈止损，与原始 MQL 版本完全一致。

概览

  • 适用市场：更适合趋势行情或伴随方向性爆发的突破走势。
  • 交易方向：可做多也可做空，但同一时间仅持有一个方向的仓位。
  • 时间框架：由 CandleType 参数控制（默认使用 1 小时 K 线）。
  • 数据来源：只在 K 线收盘后处理，通过 AverageDirectionalIndex 指标获得 ADX、+DI、-DI 数值。

交易逻辑

  1. 订阅所选时间框架的蜡烛图，并以 AdxPeriod 设置创建 ADX 指标。
  2. 对每根收盘 K 线，记录 +DI 与 -DI，历史缓存长度仅保留 Shift 所需的数量。默认的 Shift = 1 表示使用上一根已收盘 K 线的数据。
  3. 做多条件：若偏移后的 +DI 值上穿 LevelPlus，且其前一值仍在该阈值下方，同时当前没有持仓，则市价买入。
  4. 做空条件：若偏移后的 -DI 值上穿 LevelMinus，且其前一值仍在该阈值下方，同时当前没有持仓，则市价卖出。
  5. 平仓完全依赖 StartProtection 启动的保护单：固定点数的止盈与止损，分别对应原脚本中的 TP 和 SL。

策略不会在持仓期间加仓，也不会在保护单之外进行额外的出场控制，从而忠实复刻原始 EA 的轻量化逻辑。

参数

参数 默认值 说明
CandleType 1 小时时间框架 用于计算 ADX 的蜡烛类型。
AdxPeriod 28 ADX 及其 Directional Movement 计算的周期。
LevelPlus 5 +DI 必须突破的阈值，触发做多。
LevelMinus 5 -DI 必须突破的阈值，触发做空。
Shift 1 向前查看的已收盘 K 线数量（1 = 上一根 K 线）。
TakeProfitPoints 500 止盈距离（点）。内部会乘以品种的最小价格步长。
StopLossPoints 500 止损距离（点）。
TradeVolume 0.1 每次下单的基础手数，对应原专家的 Lots 参数。

风险控制

  • StartProtection 会根据合约的 PriceStep 将点数转换为绝对价格距离，再下达止盈止损订单。
  • 策略不包含移动止损或保本处理，退出完全依赖预设保护单。

使用提示

  • 阈值设置过低会导致频繁的震荡交易，适度提高 LevelPlus 与 LevelMinus 可过滤噪音，仅在强势突破时入场。
  • 通过增加 Shift 可以让策略基于更早的信号确认，适用于高时间框架或想要额外稳健性的场景。
  • 请避免人工干预或在同一账户上运行其他策略，否则可能与该策略的持仓管理发生冲突。
using System;
using System.Linq;
using System.Collections.Generic;

using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Reimplementation of the YTG ADX threshold breakout expert using high level StockSharp API.
/// The strategy waits for the +DI or -DI line to break above configurable levels and opens
/// a position in the corresponding direction with protective stop-loss and take-profit.
/// </summary>
public class YtgAdxLevelCrossStrategy : Strategy
{
	private readonly StrategyParam<int> _adxPeriod;
	private readonly StrategyParam<int> _levelPlus;
	private readonly StrategyParam<int> _levelMinus;
	private readonly StrategyParam<int> _shift;
	private readonly StrategyParam<decimal> _takeProfitPoints;
	private readonly StrategyParam<decimal> _stopLossPoints;
	private readonly StrategyParam<decimal> _tradeVolume;
	private readonly StrategyParam<DataType> _candleType;

	private AverageDirectionalIndex _adx;

	private readonly List<decimal> _plusDiHistory = [];
	private readonly List<decimal> _minusDiHistory = [];

	public int AdxPeriod
	{
		get => _adxPeriod.Value;
		set => _adxPeriod.Value = value;
	}

	public int LevelPlus
	{
		get => _levelPlus.Value;
		set => _levelPlus.Value = value;
	}

	public int LevelMinus
	{
		get => _levelMinus.Value;
		set => _levelMinus.Value = value;
	}

	public int Shift
	{
		get => _shift.Value;
		set => _shift.Value = value;
	}

	public decimal TakeProfitPoints
	{
		get => _takeProfitPoints.Value;
		set => _takeProfitPoints.Value = value;
	}

	public decimal StopLossPoints
	{
		get => _stopLossPoints.Value;
		set => _stopLossPoints.Value = value;
	}

	public decimal TradeVolume
	{
		get => _tradeVolume.Value;
		set => _tradeVolume.Value = value;
	}

	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	public YtgAdxLevelCrossStrategy()
	{
		_adxPeriod = Param(nameof(AdxPeriod), 14)
			.SetGreaterThanZero()
			.SetDisplay("ADX Period", "Period for the Average Directional Index", "Indicators")
			
			.SetOptimize(10, 40, 2);

		_levelPlus = Param(nameof(LevelPlus), 15)
			.SetNotNegative()
			.SetDisplay("+DI Level", "Threshold that the +DI line must break", "Signals")
			
			.SetOptimize(5, 40, 5);

		_levelMinus = Param(nameof(LevelMinus), 15)
			.SetNotNegative()
			.SetDisplay("-DI Level", "Threshold that the -DI line must break", "Signals")
			
			.SetOptimize(5, 40, 5);

		_shift = Param(nameof(Shift), 1)
			.SetNotNegative()
			.SetDisplay("Signal Shift", "Number of closed candles to look back", "Signals")
			
			.SetOptimize(0, 3, 1);

		_takeProfitPoints = Param(nameof(TakeProfitPoints), 500m)
			.SetNotNegative()
			.SetDisplay("Take Profit (points)", "Distance to take profit in price points", "Risk");

		_stopLossPoints = Param(nameof(StopLossPoints), 500m)
			.SetNotNegative()
			.SetDisplay("Stop Loss (points)", "Distance to stop loss in price points", "Risk");

		_tradeVolume = Param(nameof(TradeVolume), 0.1m)
			.SetGreaterThanZero()
			.SetDisplay("Trade Volume", "Base volume for market orders", "Orders");

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(1).TimeFrame())
			.SetDisplay("Candle Type", "Primary timeframe for the strategy", "General");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	protected override void OnReseted()
	{
		base.OnReseted();

		_plusDiHistory.Clear();
		_minusDiHistory.Clear();
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		Volume = TradeVolume;

		_adx = new AverageDirectionalIndex
		{
			Length = AdxPeriod
		};

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(ProcessCandle)
			.Start();

		var step = Security.PriceStep ?? 1m;
		Unit takeProfit = null;
		Unit stopLoss = null;

		if (TakeProfitPoints > 0)
			takeProfit = new Unit(TakeProfitPoints * step, UnitTypes.Absolute);

		if (StopLossPoints > 0)
			stopLoss = new Unit(StopLossPoints * step, UnitTypes.Absolute);

		if (takeProfit != null || stopLoss != null)
		{
			StartProtection(takeProfit: takeProfit, stopLoss: stopLoss);
		}
	}

	private void ProcessCandle(ICandleMessage candle)
	{
		if (candle.State != CandleStates.Finished)
			return;

		var adxValue = _adx.Process(candle);

		if (!_adx.IsFormed || !adxValue.IsFinal)
			return;

		if (adxValue is not AverageDirectionalIndexValue typed)
			return;

		if (typed.Dx.Plus is not decimal plusDi || typed.Dx.Minus is not decimal minusDi)
			return;

		UpdateHistory(_plusDiHistory, plusDi);
		UpdateHistory(_minusDiHistory, minusDi);

		var currentShift = Shift;
		var minCount = currentShift + 2;

		if (_plusDiHistory.Count < minCount || _minusDiHistory.Count < minCount)
			return;

		var currentIndex = _plusDiHistory.Count - 1 - currentShift;
		var previousIndex = currentIndex - 1;

		if (previousIndex < 0)
			return;

		var shiftedPlus = _plusDiHistory[currentIndex];
		var shiftedPlusPrev = _plusDiHistory[previousIndex];
		var shiftedMinus = _minusDiHistory[currentIndex];
		var shiftedMinusPrev = _minusDiHistory[previousIndex];

		var longSignal = shiftedPlus > LevelPlus && shiftedPlusPrev < LevelPlus;
		var shortSignal = shiftedMinus > LevelMinus && shiftedMinusPrev < LevelMinus;

		if (Position == 0)
		{
			if (longSignal)
			{
				// Enter a long position when +DI breaks above the configured level.
				BuyMarket();
			}
			else if (shortSignal)
			{
				// Enter a short position when -DI breaks above the configured level.
				SellMarket();
			}
		}
	}

	private void UpdateHistory(List<decimal> history, decimal value)
	{
		history.Add(value);

		var maxLength = Shift + 2;

		while (history.Count > maxLength)
		{
			// Keep only the amount of history required for the configured shift.
			history.RemoveAt(0);
		}
	}
}