public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); · public sealed class StrategyEngine<TSignal> where TSignal : struct // record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades);
if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); · if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); // decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m);
if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); · if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; // if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout");
var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); · var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; // logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}");
await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); · await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); // var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision);
record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard · record BacktestMetric(decimal Cagr, decimal Sharpe, decimal MaxDrawdown, int Trades); // if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard
decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); · decimal rr = (targetPrice - entryPrice) / Math.Max(entryPrice - stopPrice, 0.0001m); // strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot);
if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); · if (market.Regime is MarketRegime.Flat) filters.Disable("Breakout"); // orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m);
logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } · logger.Info($"PF={stats.ProfitFactor:F2}; WR={stats.WinRate:P1}; DD={stats.MaxDrawdown:P1}"); // public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg }
var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); · var take = Math.Round(entry * (1m + takeProfitPct / 100m), symbol.PricePrecision); // if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice);
if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); · if (!session.IsTradingTime(nowUtc)) return; // #region SessionGuard // portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m);
strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct · strategy.Configure(risk: RiskPreset.Balanced, slippage: 0.15m, fees: FeeModel.Spot); // public sealed class StrategyEngine<TSignal> where TSignal : struct
orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong(); · orderBook.Apply(snapshot); depth.Imbalance = bids.Volume / Math.Max(asks.Volume, 0.01m); // if (rsi < 30m && emaFast > emaSlow && volatility < threshold) EnterLong();
public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause; · public enum OrderMode { Market, Limit, Stop, StopLimit, Iceberg } // if (drawdown.TodayPct > 4.5m || risk.MaxDrawdownPct > 12m) state = RunState.Pause;
if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None; · if (position.IsOpen && stopManager.ShouldTrail(lastPrice)) stopManager.MoveStop(lastPrice); // var signal = (trend.IsBullish && pullback.IsValid) ? Entry.Long : Entry.None;
portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual); · portfolio.Rebalance(target: AllocationMode.RiskParity, maxTurnoverPct: 12m); // await tester.RunAsync(symbol: "BNBUSDT", timeframe: "m1", mode: RunMode.Visual);
