日本語 JA
GitHub で見る

MartingailExpert v1.0 Stochastic 戦略 (C#)

概要

MartingailExpert v1.0 Stochastic 戦略 は、MetaTrader 4 エキスパート アドバイザーを直接変換したものです。 MartingailExpert_v1_0_Stochastic.mq4。この戦略は、Stochastic オシレーターの %K/%D ラインを監視します。 そして、前に完了したバーが上に勢いを確認したときにポジションをオープンします（ロングの場合） またはそれ以下 (ショートの場合) 設定可能なしきい値ゾーン。最初の取引が開始されると、アルゴリズムは 追加成行注文のマーチンゲールはしご。量が幾何級数的に増加し、利益確定が共有される は、最新の追加価格に依然として固定されています。

変換は、StockSharp のハイレベルな API、つまりローソク足のサブスクリプション、インジケーター バインディング、および 組み込みの BuyMarket/SellMarket ヘルパー。すべてのコードのコメントは英語で書き直され、実装は プロジェクト ガイドラインで要求されるタブベースのインデント スタイルに従います。

取引ロジック

1. エントリーシグナル

  1. Stochastic オシレーター (Length = KPeriod、%K スムージング = Slowing、%D スムージング = DPeriod) は メインのキャンドルサブスクリプションにバインドされています。完成したキャンドルのみが加工されます。
  2. この戦略は、以前のバー値を保存することで、元の MQL 呼び出し iStochastic(..., shift = 1) を模倣します。 %K と %D の。長いエントリは、K_prev > D_prev と D_prev > ZoneBuy のときにトリガーされます。短いエントリーは、 K_prev < D_prev と D_prev < ZoneSell のときにトリガーされます。
  3. 最初の取引では、BuyVolume または SellVolume を使用し、反対方向の状態をリセットして回避します。 長い梯子と短い梯子を混ぜます。

2. Martingale の平均化

  1. 開いたクラスター (_buyOrderCount または _sellOrderCount が 0 より大きい) がある場合は常に、戦略 ローソク足の安値（ロングの場合）または高値（ショートの場合）を監視します。
  2. ステップ計算
    • StepMode = 0: 次の追加は、価格がちょうど StepPoints × PointSize だけ動くのを待ちます。 最新の約定注文。
    • StepMode = 1: 距離は StepPoints + max(0, 2 × ordersCount − 2) ポイントとなり、 MQL 式 step + OrdersTotal*2 - 2。エクスプレッションにはインストゥルメントのポイント サイズが乗算されます。 (Security.PriceStep から派生し、10 進数の 3/5 FX 相場に調整されています)。
  3. ローソク足がトリガーレベルに違反した場合、ストラテジーはボリュームが等しい即時成行注文を送信します。 previousVolume × Multiplier。音量は楽器の VolumeStep に正規化され、上限は VolumeMax (利用可能な場合)、VolumeMin を下回る場合はゼロに切り捨てられます。
  4. 追加するたびに、共有目標価格は次のように更新されます。 方向に応じて lastEntryPrice ± ProfitFactorPoints × PointSize × orderCount。

3. 利食い経営

  1. ローソク足が共有目標価格（ロングの場合は High >= target、 Low <= target ショートパンツ用）。追加のチェックでは、加重値を使用して価格距離利益を推定します。 MQL の元の OrderProfit() セーフガードを反映した平均エントリー価格。
  2. すべてのオープン注文は単一の SellMarket(Math.Abs(Position)) または BuyMarket(Math.Abs(Position)) に電話します。正常に終了すると、内部マーチンゲール状態がリセットされます。
  3. 外部環境がポジションをクローズした場合（手動介入、ストップアウト）、次のローソク足は Position == 0 はキャッシュされたマーチンゲール状態を自動的にクリアし、戦略の一貫性を保ちます。

4. 追加の実装上の注意事項

  • ポイント サイズは Security.PriceStep から導出されます。 3 桁または 5 桁の 10 進数の FX シンボルの場合、値が乗算されます。 ピップ (Point) の MetaTrader の概念をエミュレートするには、10 倍します。
  • StartProtection() は OnStarted で 1 回呼び出されるため、プラットフォームは共通の保護動作を付加できます (タイムアウト、ハートビートなど)。
  • この戦略では、ローソク足、確率指標、および独自の取引を専用のチャート領域に描画して、より簡単に バックテスト中の目視検査。

パラメーター

名前 種類 デフォルト 説明
StepPoints 10進数 25 別のマーチンゲール注文が行われるまでのポイント単位の距離。
StepMode 整数 0 0 – 固定距離、1 – 固定プラス 2 × ordersCount − 2 ポイント。
ProfitFactorPoints 10進数 10 クラスターのテイクプロフィットを計算するためにオープン注文ごとに追加 (または減算) されるポイント。
Multiplier 10進数 1.5 次の追加のために最後の注文量に適用される乗数。
BuyVolume 10進数 0.01 最初のロング注文のボリューム。
SellVolume 10進数 0.01 最初の空売り注文のボリューム。
KPeriod 整数 200 確率的オシレーターのルックバック期間。
DPeriod 整数 20 %D 信号線の平滑化期間。
Slowing 整数 20 %K (MetaTrader の slowing) に追加の平滑化が適用されました。
ZoneBuy 10進数 50 長いエントリを許可するには最小 %D 値が必要です。
ZoneSell 10進数 50 短いエントリを許可するには最大 %D 値が必要です。
CandleType DataType 5m time frame すべてのインジケーターの計算に使用されるローソク足のタイプ。

フォルダー構造

「」 API/3991/ §── CS/ │ └── MartingailExpertV10StochasticStrategy.cs §── README.md §── README_zh.md ━── README_ru.md 「」

Python の実装は、タスクの要件に従って意図的に省略されています。

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>
/// Conversion of the "MartingailExpert v1.0 Stochastic" MetaTrader expert advisor.
/// Implements stochastic based entries with martingale averaging and cluster take profits.
/// </summary>
public class MartingailExpertV10StochasticStrategy : Strategy
{
	private readonly StrategyParam<decimal> _stepPoints;
	private readonly StrategyParam<int> _stepMode;
	private readonly StrategyParam<decimal> _profitFactorPoints;
	private readonly StrategyParam<decimal> _multiplier;
	private readonly StrategyParam<int> _kPeriod;
	private readonly StrategyParam<int> _dPeriod;
	private readonly StrategyParam<decimal> _zoneBuy;
	private readonly StrategyParam<decimal> _zoneSell;
	private readonly StrategyParam<DataType> _candleType;

	private StochasticOscillator _stochastic;

	private decimal _pointSize;
	private decimal? _prevK;
	private decimal? _prevD;

	private decimal _buyLastPrice;
	private decimal _buyLastVolume;
	private decimal _buyTotalVolume;
	private decimal _buyWeightedSum;
	private int _buyOrderCount;
	private decimal _buyTakeProfit;

	private decimal _sellLastPrice;
	private decimal _sellLastVolume;
	private decimal _sellTotalVolume;
	private decimal _sellWeightedSum;
	private int _sellOrderCount;
	private decimal _sellTakeProfit;

	/// <summary>
	/// Distance in points that price has to travel against the latest entry before adding.
	/// </summary>
	public decimal StepPoints
	{
		get => _stepPoints.Value;
		set => _stepPoints.Value = value;
	}

	/// <summary>
	/// Step mode: 0 - fixed, 1 - fixed plus extra points per filled order.
	/// </summary>
	public int StepMode
	{
		get => _stepMode.Value;
		set => _stepMode.Value = value;
	}

	/// <summary>
	/// Profit target in points applied to every open order.
	/// </summary>
	public decimal ProfitFactorPoints
	{
		get => _profitFactorPoints.Value;
		set => _profitFactorPoints.Value = value;
	}

	/// <summary>
	/// Martingale multiplier for the next averaging order.
	/// </summary>
	public decimal Multiplier
	{
		get => _multiplier.Value;
		set => _multiplier.Value = value;
	}

	/// <summary>
	/// Stochastic %K lookback period.
	/// </summary>
	public int KPeriod
	{
		get => _kPeriod.Value;
		set => _kPeriod.Value = value;
	}

	/// <summary>
	/// Stochastic %D smoothing length.
	/// </summary>
	public int DPeriod
	{
		get => _dPeriod.Value;
		set => _dPeriod.Value = value;
	}

	/// <summary>
	/// Minimum stochastic level that confirms long setups.
	/// </summary>
	public decimal ZoneBuy
	{
		get => _zoneBuy.Value;
		set => _zoneBuy.Value = value;
	}

	/// <summary>
	/// Maximum stochastic level that confirms short setups.
	/// </summary>
	public decimal ZoneSell
	{
		get => _zoneSell.Value;
		set => _zoneSell.Value = value;
	}

	/// <summary>
	/// Candle type used for calculations.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Initializes a new instance of <see cref="MartingailExpertV10StochasticStrategy"/>.
	/// </summary>
	public MartingailExpertV10StochasticStrategy()
	{
		_stepPoints = Param(nameof(StepPoints), 500m)
			.SetGreaterThanZero()
			.SetDisplay("Step", "Price step in points before averaging", "Martingale");

		_stepMode = Param(nameof(StepMode), 0)
			.SetDisplay("Step Mode", "0 - fixed step, 1 - step plus extra points per order", "Martingale");

		_profitFactorPoints = Param(nameof(ProfitFactorPoints), 300m)
			.SetGreaterThanZero()
			.SetDisplay("Profit Factor", "Points multiplied by order count for take profit", "Martingale");

		_multiplier = Param(nameof(Multiplier), 1.5m)
			.SetGreaterThanZero()
			.SetDisplay("Multiplier", "Martingale multiplier for averaging", "Martingale");

		_kPeriod = Param(nameof(KPeriod), 14)
			.SetGreaterThanZero()
			.SetDisplay("%K Period", "Stochastic %K lookback", "Indicators");

		_dPeriod = Param(nameof(DPeriod), 3)
			.SetGreaterThanZero()
			.SetDisplay("%D Period", "Stochastic %D smoothing", "Indicators");

		_zoneBuy = Param(nameof(ZoneBuy), 50m)
			.SetDisplay("Zone Buy", "%D lower bound to allow buys", "Indicators");

		_zoneSell = Param(nameof(ZoneSell), 50m)
			.SetDisplay("Zone Sell", "%D upper bound to allow sells", "Indicators");

		_candleType = Param(nameof(CandleType), TimeSpan.FromMinutes(10).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe used for processing", "General");

		Volume = 1;
	}

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

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_stochastic = null;
		_pointSize = 0m;
		_prevK = null;
		_prevD = null;
		ResetLongState();
		ResetShortState();
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		_pointSize = Security?.PriceStep ?? 1m;
		if (_pointSize <= 0m) _pointSize = 1m;

		_stochastic = new StochasticOscillator();
		_stochastic.K.Length = KPeriod;
		_stochastic.D.Length = DPeriod;

		var subscription = SubscribeCandles(CandleType);
		subscription
			.BindEx(_stochastic, ProcessCandle)
			.Start();

		var area = CreateChartArea();
		if (area != null)
		{
			DrawCandles(area, subscription);
			DrawOwnTrades(area);

			var indArea = CreateChartArea();
			if (indArea != null)
				DrawIndicator(indArea, _stochastic);
		}

		base.OnStarted2(time);
	}

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

		if (stochasticValue is not StochasticOscillatorValue stoch)
			return;

		if (stoch.K is not decimal currentK || stoch.D is not decimal currentD)
			return;

		if (!_stochastic.IsFormed)
		{
			_prevK = currentK;
			_prevD = currentD;
			return;
		}

		var tradingAllowed = IsFormedAndOnlineAndAllowTrading();

		ManageClusters(candle, tradingAllowed);

		if (!tradingAllowed)
		{
			_prevK = currentK;
			_prevD = currentD;
			return;
		}

		// Entry logic: stochastic crossover in oversold/overbought zones
		if (Position == 0m && _buyOrderCount == 0 && _sellOrderCount == 0
			&& _prevK is decimal prevK && _prevD is decimal prevD)
		{
			if (prevK > prevD && prevD > ZoneBuy)
			{
				OpenLong(candle.ClosePrice);
			}
			else if (prevK < prevD && prevD < ZoneSell)
			{
				OpenShort(candle.ClosePrice);
			}
		}

		_prevK = currentK;
		_prevD = currentD;
	}

	private void ManageClusters(ICandleMessage candle, bool tradingAllowed)
	{
		if (Position > 0m && _buyOrderCount > 0)
		{
			HandleLongCluster(candle, tradingAllowed);
		}
		else if (Position < 0m && _sellOrderCount > 0)
		{
			HandleShortCluster(candle, tradingAllowed);
		}
		else if (Position == 0m)
		{
			if (_buyOrderCount > 0 || _sellOrderCount > 0)
			{
				ResetLongState();
				ResetShortState();
			}
		}
	}

	private void HandleLongCluster(ICandleMessage candle, bool tradingAllowed)
	{
		if (!tradingAllowed || _pointSize <= 0m)
			return;

		// Check take profit first
		if (_buyTakeProfit > 0m && candle.HighPrice >= _buyTakeProfit)
		{
			SellMarket(Math.Abs(Position));
			ResetLongState();
			return;
		}

		// Average down
		var currentCount = Math.Max(1, _buyOrderCount);
		var stepPts = StepMode == 0
			? StepPoints
			: StepPoints + Math.Max(0m, currentCount * 2m - 2m);
		var addTrigger = _buyLastPrice - stepPts * _pointSize;

		if (_buyLastVolume > 0m && candle.LowPrice <= addTrigger)
		{
			var nextVolume = Math.Max(1m, Math.Round(_buyLastVolume * Multiplier));
			BuyMarket(nextVolume);

			var executionPrice = candle.ClosePrice;
			_buyLastVolume = nextVolume;
			_buyLastPrice = executionPrice;
			_buyTotalVolume += nextVolume;
			_buyWeightedSum += executionPrice * nextVolume;
			_buyOrderCount++;
			RecalcLongTp();
		}
	}

	private void HandleShortCluster(ICandleMessage candle, bool tradingAllowed)
	{
		if (!tradingAllowed || _pointSize <= 0m)
			return;

		// Check take profit first
		if (_sellTakeProfit > 0m && candle.LowPrice <= _sellTakeProfit)
		{
			BuyMarket(Math.Abs(Position));
			ResetShortState();
			return;
		}

		// Average up
		var currentCount = Math.Max(1, _sellOrderCount);
		var stepPts = StepMode == 0
			? StepPoints
			: StepPoints + Math.Max(0m, currentCount * 2m - 2m);
		var addTrigger = _sellLastPrice + stepPts * _pointSize;

		if (_sellLastVolume > 0m && candle.HighPrice >= addTrigger)
		{
			var nextVolume = Math.Max(1m, Math.Round(_sellLastVolume * Multiplier));
			SellMarket(nextVolume);

			var executionPrice = candle.ClosePrice;
			_sellLastVolume = nextVolume;
			_sellLastPrice = executionPrice;
			_sellTotalVolume += nextVolume;
			_sellWeightedSum += executionPrice * nextVolume;
			_sellOrderCount++;
			RecalcShortTp();
		}
	}

	private void OpenLong(decimal price)
	{
		BuyMarket(Volume);

		_buyLastPrice = price;
		_buyLastVolume = Volume;
		_buyTotalVolume = Volume;
		_buyWeightedSum = price * Volume;
		_buyOrderCount = 1;
		RecalcLongTp();

		ResetShortState();
	}

	private void OpenShort(decimal price)
	{
		SellMarket(Volume);

		_sellLastPrice = price;
		_sellLastVolume = Volume;
		_sellTotalVolume = Volume;
		_sellWeightedSum = price * Volume;
		_sellOrderCount = 1;
		RecalcShortTp();

		ResetLongState();
	}

	private void RecalcLongTp()
	{
		var avg = _buyTotalVolume > 0 ? _buyWeightedSum / _buyTotalVolume : _buyLastPrice;
		_buyTakeProfit = avg + ProfitFactorPoints * _pointSize;
	}

	private void RecalcShortTp()
	{
		var avg = _sellTotalVolume > 0 ? _sellWeightedSum / _sellTotalVolume : _sellLastPrice;
		_sellTakeProfit = avg - ProfitFactorPoints * _pointSize;
	}

	private void ResetLongState()
	{
		_buyLastPrice = 0m;
		_buyLastVolume = 0m;
		_buyTotalVolume = 0m;
		_buyWeightedSum = 0m;
		_buyOrderCount = 0;
		_buyTakeProfit = 0m;
	}

	private void ResetShortState()
	{
		_sellLastPrice = 0m;
		_sellLastVolume = 0m;
		_sellTotalVolume = 0m;
		_sellWeightedSum = 0m;
		_sellOrderCount = 0;
		_sellTakeProfit = 0m;
	}
}