日本語 JA
GitHub で見る

Candles Smoothed Strategy

This strategy trades based on the color of smoothed candles. For each finished candle, the difference between the close and open price is passed through a moving average. When this smoothed difference changes sign, the candle "color" switches and the strategy reverses its position.

Logic

  1. Subscribe to a configurable candle series.
  2. Calculate diff = close - open for every finished candle.
  3. Smooth the diff using the selected moving average.
  4. Determine candle color:
    • Color 0 if smoothed diff > 0 (close above open).
    • Color 1 otherwise.
  5. Generate signals:
    • Buy when color changes from 0 to 1.
    • Sell when color changes from 1 to 0.
  6. The current position is closed before entering a new one.

Parameters

  • CandleType – timeframe of the processed candles. Default is 1 hour.
  • MaLength – length of the smoothing moving average. Default is 30.
  • MaMethods – moving average algorithm: Simple, Exponential, Smma, or Weighted. Default is Weighted.

Notes

  • The strategy uses market orders via BuyMarket and SellMarket.
  • High-level API is used for candle subscription and chart visualization.
  • Indicator values are accessed through TryGetValue to avoid direct buffer calls.
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>
/// Strategy based on smoothed candle body direction.
/// Smooths (close-open) with WMA, trades on color changes.
/// </summary>
public class CandlesSmoothedStrategy : Strategy
{
	private readonly StrategyParam<DataType> _candleType;
	private readonly StrategyParam<int> _maLength;

	private WeightedMovingAverage _ma;
	private int? _prevColor;

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

	public CandlesSmoothedStrategy()
	{
		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Time frame", "General");

		_maLength = Param(nameof(MaLength), 30)
			.SetGreaterThanZero()
			.SetDisplay("MA Length", "Moving average smoothing length", "Indicator");
	}

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

	protected override void OnReseted()
	{
		base.OnReseted();
		_ma = null;
		_prevColor = null;
	}

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

		_ma = new WeightedMovingAverage { Length = MaLength };
		Indicators.Add(_ma);

		// Use a dummy EMA for warmup binding
		var warmup = new ExponentialMovingAverage { Length = MaLength };

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

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

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

		// Calculate close-open diff and smooth with WMA
		var diff = candle.ClosePrice - candle.OpenPrice;
		var maResult = _ma.Process(new DecimalIndicatorValue(_ma, diff, candle.OpenTime) { IsFinal = true });

		if (!maResult.IsFormed)
			return;

		var smoothed = maResult.GetValue<decimal>();
		var color = smoothed > 0m ? 0 : 1;

		if (!IsFormedAndOnlineAndAllowTrading())
		{
			_prevColor = color;
			return;
		}

		if (_prevColor is int prev)
		{
			// Color change from negative to positive -> buy
			if (color == 1 && prev == 0 && Position <= 0)
				BuyMarket();
			// Color change from positive to negative -> sell
			else if (color == 0 && prev == 1 && Position >= 0)
				SellMarket();
		}

		_prevColor = color;
	}
}