public static bool GetIsAutoStart(this StrategyContainer strategy)
{
if (strategy == null)
{
throw new ArgumentNullException("strategy");
}
return(strategy.StrategyInfo.StrategyType != null && strategy.StrategyInfo.StrategyType.GetAttribute <AutoStartAttribute>() != null);
}
public static void SetIsInitialization(this StrategyContainer strategy, bool isInitialization)
{
if (strategy.Strategy != null)
{
strategy.Strategy.SetIsInitialization(isInitialization);
}
strategy.Environment.SetValue("IsInitializationMode", isInitialization);
}
public static bool GetIsInteracted(this StrategyContainer strategy)
{
if (strategy == null)
{
throw new ArgumentNullException(nameof(strategy));
}
return(strategy.StrategyInfo.StrategyType != null && strategy.StrategyInfo.StrategyType.GetAttribute <InteractedStrategyAttribute>() != null);
}
public static void InitStrategy(this StrategyContainer container)
{
var info = container.StrategyInfo;
switch (info.Type)
{
case StrategyInfoTypes.SourceCode:
case StrategyInfoTypes.Analytics:
{
if (info.StrategyType != null)
{
container.Strategy = info.StrategyType.CreateInstance <Strategy>();
}
break;
}
case StrategyInfoTypes.Diagram:
{
GuiDispatcher.GlobalDispatcher.AddAction(() =>
{
var strategy = (DiagramStrategy)container.Strategy;
if (strategy == null)
{
container.Strategy = strategy = new DiagramStrategy();
}
try
{
strategy.Composition = ConfigManager.GetService <CompositionRegistry>().Deserialize(info.Body.LoadSettingsStorage());
}
catch (Exception ex)
{
strategy.AddErrorLog(LocalizedStrings.Str3175Params, ex);
}
});
break;
}
case StrategyInfoTypes.Terminal:
case StrategyInfoTypes.Assembly:
{
if (info.StrategyType != null)
{
container.Strategy = info.StrategyType.CreateInstance <Strategy>();
}
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
public CandleChartPanel()
{
InitializeComponent();
var cmdSvc = ConfigManager.GetService<IStudioCommandService>();
cmdSvc.Register<ChartDrawCommand>(this, false, cmd => _bufferedChart.Draw(cmd.Values));
cmdSvc.Register<ChartAddAreaCommand>(this, false, cmd => _bufferedChart.AddArea(cmd.Area));
cmdSvc.Register<ChartRemoveAreaCommand>(this, false, cmd => _bufferedChart.RemoveArea(cmd.Area));
cmdSvc.Register<ChartAddElementCommand>(this, false, cmd => _bufferedChart.AddElement(cmd.Area, cmd.Element));
cmdSvc.Register<ChartRemoveElementCommand>(this, false, cmd => _bufferedChart.RemoveElement(cmd.Area, cmd.Element));
cmdSvc.Register<ChartClearAreasCommand>(this, false, cmd => _bufferedChart.ClearAreas());
cmdSvc.Register<ChartResetElementsCommand>(this, false, cmd => _bufferedChart.Reset(cmd.Elements));
cmdSvc.Register<ChartAutoRangeCommand>(this, false, cmd => _bufferedChart.IsAutoRange = cmd.AutoRange);
cmdSvc.Register<ResetedCommand>(this, true, cmd => OnReseted());
cmdSvc.Register<BindStrategyCommand>(this, true, cmd =>
{
if (!cmd.CheckControl(this))
return;
if (_strategy == cmd.Source)
return;
_strategy = cmd.Source;
SetChart(true);
ChartPanel.IsInteracted = _strategy != null && _strategy.GetIsInteracted();
if (_settingsStorage != null)
ChartPanel.Load(_settingsStorage);
TryCreateDefaultSeries();
});
ChartPanel.SettingsChanged += () => new ControlChangedCommand(this).Process(this);
ChartPanel.RegisterOrder += order => new RegisterOrderCommand(order).Process(this);
ChartPanel.SubscribeCandleElement += OnChartPanelSubscribeCandleElement;
ChartPanel.SubscribeIndicatorElement += OnChartPanelSubscribeIndicatorElement;
ChartPanel.SubscribeOrderElement += OnChartPanelSubscribeOrderElement;
ChartPanel.SubscribeTradeElement += OnChartPanelSubscribeTradeElement;
ChartPanel.UnSubscribeElement += OnChartPanelUnSubscribeElement;
var indicatorTypes = ConfigManager
.GetService<IAlgoService>()
.IndicatorTypes;
ChartPanel.MinimumRange = 200;
ChartPanel.IndicatorTypes.AddRange(indicatorTypes);
_bufferedChart = new BufferedChart(ChartPanel);
WhenLoaded(() => new RequestBindSource(this).SyncProcess(this));
}
public StrategyConnector(StrategyContainer strategy, DateTimeOffset startDate, DateTimeOffset stopDate, TimeSpan useCandlesTimeFrame, bool onlyInitialize)
{
if (strategy == null)
throw new ArgumentNullException(nameof(strategy));
UpdateSecurityLastQuotes = false;
UpdateSecurityByLevel1 = false;
var entityRegistry = ConfigManager.GetService<IStudioEntityRegistry>();
_strategy = strategy;
_useCandlesTimeFrame = useCandlesTimeFrame;
_onlyInitialize = onlyInitialize;
_sessionStrategy = entityRegistry.ReadSessionStrategyById(strategy.Strategy.Id);
if (_sessionStrategy == null)
throw new InvalidOperationException("sessionStrategy = null");
Id = strategy.Id;
Name = strategy.Name + " Connector";
_realConnector = (StudioConnector)ConfigManager.GetService<IStudioConnector>();
_realConnector.NewMessage += RealConnectorNewMessage;
_securityProvider = new StudioSecurityProvider();
var storageRegistry = new StudioStorageRegistry { MarketDataSettings = strategy.MarketDataSettings };
//EntityFactory = new StorageEntityFactory(entityRegistry, storageRegistry);
Adapter.InnerAdapters.Add(_historyMessageAdapter = new HistoryMessageAdapter(TransactionIdGenerator, _securityProvider)
{
StartDate = startDate,
StopDate = stopDate,
StorageRegistry = storageRegistry
});
//_historyMessageAdapter.UpdateCurrentTime(startDate);
var transactionAdapter = new PassThroughMessageAdapter(TransactionIdGenerator);
transactionAdapter.AddTransactionalSupport();
Adapter.InnerAdapters.Add(transactionAdapter);
_historyMessageAdapter.MarketTimeChangedInterval = useCandlesTimeFrame;
// при инициализации по свечкам, время меняется быстрее и таймаут должен быть больше 30с.
ReConnectionSettings.TimeOutInterval = TimeSpan.MaxValue;
//_historyMessageAdapter.BasketStorage.InnerStorages.AddRange(GetExecutionStorages());
this.LookupById(strategy.Security.Id);
new ChartAutoRangeCommand(true).Process(_strategy);
}
public UniversalGridPanel()
{
InitializeComponent();
ConfigManager
.GetService<IStudioCommandService>()
.Register<BindStrategyCommand>(this, true, cmd =>
{
if (!cmd.CheckControl(this))
return;
if (_strategy == cmd.Source)
return;
_strategy = cmd.Source;
SetGrid(Grid);
});
WhenLoaded(() => new RequestBindSource(this).SyncProcess(this));
}
private void StrategyAdded(StrategyContainer strategyContainer)
{
StrategiesCollectionChanged();
}
private void StrategyRemoved(StrategyContainer strategy)
{
CloseWindow(strategy.Strategy.Id.To<string>(), strategy.SessionType == SessionType.Optimization ? typeof(OptimizatorContent) : typeof(StrategyContent));
}
private IStudioControl OpenControl(StrategyContainer strategy, string contentTemplate = null)
{
switch (strategy.SessionType)
{
case SessionType.Battle:
case SessionType.Emulation:
return OpenStrategyControl(strategy, contentTemplate);
case SessionType.Optimization:
return OpenOprimizationControl(strategy);
default:
throw new ArgumentOutOfRangeException();
}
}
private IStudioControl OpenStrategyControl(StrategyContainer strategy, string contentTemplate)
{
return OpenControl(strategy.Strategy.Id.To<string>(), typeof(StrategyContent), strategy, () =>
{
var ctrl = new StrategyContent();
ctrl.SetStrategy(strategy);
ctrl.LoadTemplate(contentTemplate ?? GetDefaultContentTemplate(strategy.StrategyInfo.Type, strategy.SessionType), false);
return ctrl;
});
}
public static Guid GetStrategyId(this StrategyContainer strategyContainer)
{
var container = strategyContainer.Strategy as StrategyContainer;
return(container == null ? strategyContainer.Strategy.Id : container.GetStrategyId());
}
private IStudioControl OpenOprimizationControl(StrategyContainer strategy)
{
return OpenControl(strategy.Strategy.Id.To<string>(), typeof(OptimizatorContent), strategy, () =>
{
var c = new OptimizatorContent { Strategy = strategy };
c.SetStrategy(strategy);
return c;
});
}
private void EmulationServiceOnProgressChanged(StrategyContainer strategy, int value)
{
ResultsPanel.UpdateProgress(strategy.Strategy, value);
}
private void Stop(StrategyContainer strategy)
{
strategy
.WhenStopped()
.Do(() =>
{
var candleManager = strategy.GetCandleManager();
if (candleManager != null)
candleManager.Dispose();
strategy.SafeGetConnector().Dispose();
strategy.Connector = ConfigManager.GetService<IConnector>();
})
.Once()
.Apply();
strategy.Stop();
}
private void Start(StrategyContainer strategy, DateTime? startDate, DateTime? stopDate, TimeSpan? candlesTimeFrame, bool onlyInitialize)
{
if (Connector == null)
throw new InvalidOperationException("Connector=null");
strategy.CheckCanStart();
var from = startDate ?? DateTime.Today.AddDays(-strategy.HistoryDaysCount);
var to = stopDate ?? DateTime.Now;
var strategyConnector = new StrategyConnector(strategy, from, to, candlesTimeFrame ?? TimeSpan.FromMinutes(5), onlyInitialize);
ConfigManager.GetService<LogManager>().Sources.Add(strategyConnector);
strategy.Connector = strategyConnector;
strategy.SetCandleManager(CreateCandleManager(strategyConnector, TimeSpan.FromDays((strategy.HistoryDaysCount + 1) * 2)));
strategy.SetIsEmulation(false);
strategy.Start();
strategyConnector.Connect();
}
private void StrategyAdded(StrategyContainer strategy)
{
OpenControl(strategy);
}
private bool CanStop(StrategyContainer strategy)
{
return strategy != null && strategy.ProcessState == ProcessStates.Started;
}
public EmulationService(StrategyContainer strategy)
{
if (strategy == null)
throw new ArgumentNullException("strategy");
Strategy = strategy;
Strategies = new[] { strategy }.ToEx(1);
var storageRegistry = new StudioStorageRegistry { MarketDataSettings = Strategy.MarketDataSettings };
_basketEmulation = new BatchEmulation(new StudioSecurityProvider(), new Portfolio[0], storageRegistry);
_basketEmulation.StateChanged += BasketEmulationOnStateChanged;
_basketEmulation.ProgressChanged += (curr, total) =>
{
Progress = total;
_basketEmulation
.BatchStrategies
.OfType<StrategyContainer>()
.ForEach(s => ProgressChanged.SafeInvoke((StrategyContainer)s.Strategy, curr));
};
ConfigManager.GetService<LogManager>().Sources.Add(EmulationConnector);
EmulationConnector.HistoryMessageAdapter.StorageRegistry = storageRegistry;
CanStart = true;
}
private IEnumerable<Strategy> GetStrategies()
{
EmulationConnector.AddInfoLog(LocalizedStrings.Str3592);
var enumerator = Strategies.GetEnumerator();
while (enumerator.MoveNext())
{
var strategy = (StrategyContainer)enumerator.Current;
strategy.CheckCanStart();
var container = new StrategyContainer
{
Id = strategy.Id,
StrategyInfo = _infoClone,
MarketDataSettings = strategy.MarketDataSettings,
Connector = EmulationConnector,
//SessionType = SessionType.Optimization,
};
container.Environment.AddRange(strategy.Environment);
container.SetCandleManager(CreateCandleManager());
container.SetIsEmulation(true);
container.SetIsInitialization(false);
container.NameGenerator.Pattern = strategy.NameGenerator.Pattern;
container.Portfolio = strategy.Portfolio;
container.Security = strategy.Security;
container.Strategy = strategy;
container.UnrealizedPnLInterval = EmulationSettings.UnrealizedPnLInterval ?? ((EmulationSettings.StopTime - EmulationSettings.StartTime).Ticks / 1000).To<TimeSpan>();
_infoClone.Strategies.Add(container);
yield return container;
}
EmulationConnector.AddInfoLog(LocalizedStrings.Str3593);
}
public static bool IsDiagramStrategy(this StrategyContainer container)
{
return(container.StrategyInfo.Type == StrategyInfoTypes.Diagram);
}
private void OpenStrategy(StrategyContainer selectedStrategy)
{
var strategy = (StrategyContainer)selectedStrategy.Clone();
strategy.Strategy.Id = selectedStrategy.Strategy.Id;
strategy.Portfolio = Strategy.Portfolio;
strategy.SessionType = SessionType.Battle;
strategy.Reseted += () =>
{
var settings = EmulationService.EmulationSettings;
new StartStrategyCommand(strategy, settings.StartTime, settings.StopTime, null, true).Process(this);
};
new OpenStrategyCommand(strategy, Properties.Resources.EmulationStrategyContent).Process(strategy.StrategyInfo);
}
public static Guid GetStrategyId(this StrategyContainer strategyContainer)
{
var container = strategyContainer.Strategy as StrategyContainer;
return(container?.GetStrategyId() ?? strategyContainer.Strategy.Id);
}
