private void OnConnect()
{
_connector = new QuikTrader()
{
LuaFixServerAddress = "127.0.0.1:5002".To <EndPoint>()
};
SecurityEditor.SecurityProvider = _connector;
_candleManager = new CandleManager(_connector);
_connector.Connected += () =>
{
this.GuiAsync(() =>
{
StatusTextBlock.Text = "Соединение установлено!";
ConnectButtom.Content = "Разъединить";
});
};
_connector.Disconnected += () =>
{
this.GuiAsync(() =>
{
StatusTextBlock.Text = "Соединение разорвано!";
ConnectButtom.Content = "Соединить";
});
};
// Это обработчик событие получения свечи
_candleManager.Processing += (series, candle) =>
{
if (series != _series)
{
return;
}
// Используем только завершенные свечи
if (candle.State != CandleStates.Finished)
{
return;
}
// Рассчитываем значение индикатора
var smaValue = _sma.Process(candle);
// Создаем экземпляр класса ChartDrawData - класс, где группируются данные для отрисовки
var data = new ChartDrawData();
// chartItem - набор элементов, привязанных к одной точке на шкале X
var chartItem = data.Group(candle.OpenTime).Add(_candleElement, candle);
chartItem.Add(_indicatorElement, smaValue);
// Безопасно отрисовываем элементы на графике
this.GuiSync(() =>
{
Chart.Draw(data);
});
};
_connector.Connect();
}
public ChartWindow(CandleSeries candleSeries, DateTime from, DateTime to)
{
InitializeComponent();
if (candleSeries == null)
{
throw new ArgumentNullException(nameof(candleSeries));
}
_candleSeries = candleSeries;
_trader = MainWindow.Instance.Trader;
Chart.ChartTheme = ChartThemes.ExpressionDark;
var area = new ChartArea();
Chart.Areas.Add(area);
_candleElem = new ChartCandleElement
{
AntiAliasing = false,
UpFillColor = Colors.White,
UpBorderColor = Colors.Black,
DownFillColor = Colors.Black,
DownBorderColor = Colors.Black,
};
area.Elements.Add(_candleElem);
_trader.CandleSeriesProcessing += ProcessNewCandle;
_trader.SubscribeCandles(_candleSeries, @from, to);
Title = candleSeries.ToString();
}
private void Check_Click(object sender, RoutedEventArgs e)
{
var terminal = this.SelectedTerminal;
if (terminal.SystemProcess.MainModule == null)
{
throw new InvalidOperationException("Неподходящий процесс для обработки.");
}
this.OkResult.SetVisibility(false);
_settingErrors.Clear();
var trader = new QuikTrader(terminal.SystemProcess.MainModule.FileName);
trader.Connected += () => this.GuiAsync(() =>
{
if (this.CheckDde.IsChecked == true)
{
trader.StartExport();
}
OnConnect(trader, null);
});
trader.ConnectionError += error => this.GuiSync(() => OnConnect(trader, error));
if (this.CheckDde.IsChecked == true)
{
trader.ProcessDataError += error => _settingErrors.Add(new SettingsError("Экспорт DDE. {0}".Put(error.Message), true));
}
trader.Connect();
}
public Strategy(MainWindow mWnd)
{
mainWindow = mWnd;
InitializeComponent();
trader = mainWindow.Trader;
cbSecurity.ItemsSource = trader.Securities;
cbPortfolio.ItemsSource = trader.Portfolios;
txtSteps.Text = countOfSteps.ToString();
}
// CandleSeries candleseries = new CandleSeries();
public void Connect()
{// quiktrader.DdeTables = new [] {quiktrader.SecuritiesTable}
var terminal = QuikTerminal.Get(@"C:\BCS_Work\Учебный QUIK БКС");
if (!terminal.IsLaunched)
{
quiktrader = new QuikTrader(QuikTerminal.GetDefaultPath()) { Path = QuikTerminal.GetDefaultPath() };
Console.WriteLine("Запускается Quik...");
//candleseries = new CandleSeries();
//candlemanager.Start(candleseries);
}
private void Connect_Click(object sender, RoutedEventArgs e)
{
if (this.Path.Text.IsEmpty())
{
MessageBox.Show(this, "Путь к Quik не выбран");
}
else
{
if (_trader == null)
{
// создаем шлюз
_trader = new QuikTrader(this.Path.Text);
this.Portfolio.Trader = _trader;
// изменяем метаданные так, чтобы начали обрабатывать дополнительные колонки опционов
var columns = _trader.SecuritiesTable.Columns;
columns.Add(DdeSecurityColumns.Strike);
columns.Add(DdeSecurityColumns.Volatility);
columns.Add(DdeSecurityColumns.UnderlyingSecurity);
columns.Add(DdeSecurityColumns.TheorPrice);
columns.Add(DdeSecurityColumns.OptionType);
columns.Add(DdeSecurityColumns.ExpiryDate);
// добавляем в выпадающий список только опционы
_trader.NewSecurities += securities =>
this.GuiAsync(() => _options.AddRange(securities.Where(s => s.Type == SecurityTypes.Option)));
// подписываемся на событие новых сделок чтобы обновить текущую цену фьючерса
_trader.NewTrades += trades => this.GuiAsync(() =>
{
var option = this.SelectedOption;
if (option != null)
{
var future = option.GetUnderlyingAsset();
if (future.LastTrade != null)
{
this.BaseActivePrice.Text = future.LastTrade.Price.ToString();
}
}
});
_trader.Connected += () => _trader.StartExport();
_trader.Connect();
}
}
}
private void OnConnect(QuikTrader trader, Exception connectionError)
{
if (connectionError == null)
{
_settingErrors.AddRange(trader.Terminal.GetTableSettings()
.Select(r => new SettingsError(LocalizedStrings.Str3031Params.Put(r.Table.Caption, r.Error.Message), r.IsCritical)));
if (_settingErrors.Count == 0)
{
OkResult.SetVisibility(true);
}
}
else
{
MessageBox.Show(this, connectionError.ToString(), "Verifier");
}
trader.Dispose();
}
static void Main(string[] args)
{
IConnector connector = new QuikTrader()
{
LuaFixServerAddress = "127.0.0.1:5001".To <EndPoint>(),
LuaLogin = "******",
LuaPassword = "******".To <SecureString>()
};
ConfigManager configManager = ConfigManager.GetInstance();
CommandHandler handler = CommandHandler.GetInstance(connector);
configManager.SetOutput(Console.WriteLine);
handler.SetOutput(Console.WriteLine);
configManager.PrintAllSettings();
while (true)
{
var userMessage = Console.ReadLine()?.ToLower();
handler.ParseUserMessage(userMessage);
if (userMessage.CompareIgnoreCase(UserCommands.Dconn.ToString()))
{
break;
}
}
var counter = 10;
while (connector.ConnectionState == ConnectionStates.Connected &&
counter > 0)
{
Console.WriteLine("Trying to close safety for {0} sec.", counter);
Thread.Sleep(1000);
counter--;
}
Console.WriteLine("Press any key to exit");
Console.ReadLine();
}
private void CheckClick(object sender, RoutedEventArgs e)
{
var terminal = SelectedTerminal;
if (terminal.SystemProcess.MainModule == null)
{
throw new InvalidOperationException(LocalizedStrings.InvalidProcess);
}
OkResult.SetVisibility(false);
_settingErrors.Clear();
var isDde = IsDde.IsChecked == true;
var connector = new QuikTrader(terminal.SystemProcess.MainModule.FileName)
{
IsDde = isDde
};
var checkDde = isDde && CheckDde.IsChecked == true;
connector.Connected += () => this.GuiAsync(() =>
{
if (checkDde)
{
connector.StartExport();
}
OnConnect(connector, null);
});
connector.ConnectionError += error => this.GuiSync(() => OnConnect(connector, error));
if (checkDde)
{
connector.ProcessDataError += error => _settingErrors.Add(new SettingsError(LocalizedStrings.Str3030Params.Put(error.Message), true));
}
connector.Connect();
}
public void Dispose()
{
if (_isConnected)
{
try
{
bStopJobs = true;
if (Trader != null)
{
Trader.Disconnect();
Trader.Dispose();
Trader = null;
}
Log("Disconnected from <QUIK>");
}
catch (Exception e)
{
Log("Problem Disconnecting <QUIK>" + e);
}
}
}
private void ConnectClick(object sender, RoutedEventArgs e)
{
if (Path.Text.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2969);
}
else
{
Trader = new QuikTrader(Path.Text)
{
IsDde = true, IsAsyncMode = true
};
Portfolios.Connector = Trader;
Trader.Connected += () => this.GuiAsync(() => ExportDde.IsEnabled = true);
Trader.NewSecurities += securities => _securitiesWindow.SecurityPicker.Securities.AddRange(securities);
// подписываемся на событие о неудачной регистрации заявок
Trader.OrdersRegisterFailed += OrdersFailed;
// подписываемся на событие о неудачном снятии заявок
Trader.OrdersCancelFailed += OrdersFailed;
// подписываемся на событие о неудачной регистрации стоп-заявок
Trader.StopOrdersRegisterFailed += OrdersFailed;
// подписываемся на событие о неудачном снятии стоп-заявок
Trader.StopOrdersCancelFailed += OrdersFailed;
// добавляем экспорт дополнительных колонок из стакана (своя покупка и продажа)
Trader.QuotesTable.Columns.Add(DdeQuoteColumns.OwnBidVolume);
Trader.QuotesTable.Columns.Add(DdeQuoteColumns.OwnAskVolume);
Trader.Connect();
ShowSecurities.IsEnabled = true;
ConnectBtn.IsEnabled = false;
}
}
private void ConnectClick(object sender, RoutedEventArgs e)
{
if (Path.Text.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2983);
}
else
{
_trader = new QuikTrader(Path.Text)
{
IsDde = true
};
_trader.Connected += () => this.GuiAsync(() => ExportDde.IsEnabled = true);
_trader.NewSecurities += securities => this.GuiAsync(() => Security.ItemsSource = _trader.Securities);
_trader.Connect();
_candleManager = new CandleManager(_trader);
_candleManager.Processing += DrawCandle;
ConnectBtn.IsEnabled = false;
}
}
private void ConnectClick(object sender, RoutedEventArgs e)
{
if (!_isConnected)
{
var isLua = IsLua.IsChecked == true;
if (isLua)
{
if (Address.Text.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2977);
return;
}
if (Login.Text.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2978);
return;
}
if (Password.Password.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2979);
return;
}
}
else
{
if (QuikPath.Folder.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2969);
return;
}
}
if (Trader == null)
{
// создаем подключение
Trader = isLua
? new QuikTrader
{
LuaFixServerAddress = Address.Text.To <EndPoint>(),
LuaLogin = Login.Text,
LuaPassword = Password.Password.To <SecureString>()
}
: new QuikTrader(QuikPath.Folder)
{
IsDde = true
};
Trader.LogLevel = LogLevels.Debug;
_logManager.Sources.Add(Trader);
// отключение автоматического запроса всех инструментов.
Trader.RequestAllSecurities = AllSecurities.IsChecked == true;
// возводим флаг, что соединение установлено
_isConnected = true;
// переподключение будет работать только во время работы биржи РТС
// (чтобы отключить переподключение когда торгов нет штатно, например, ночью)
Trader.ReConnectionSettings.WorkingTime = ExchangeBoard.Forts.WorkingTime;
// подписываемся на событие об успешном восстановлении соединения
Trader.Restored += () => this.GuiAsync(() => MessageBox.Show(this, LocalizedStrings.Str2958));
// подписываемся на событие разрыва соединения
Trader.ConnectionError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString()));
// подписываемся на ошибку обработки данных (транзакций и маркет)
//Trader.Error += error =>
// this.GuiAsync(() => MessageBox.Show(this, error.ToString(), "Ошибка обработки данных"));
// подписываемся на ошибку подписки маркет-данных
Trader.MarketDataSubscriptionFailed += (security, msg, error) =>
this.GuiAsync(() => MessageBox.Show(this, error.ToString(), LocalizedStrings.Str2956Params.Put(msg.DataType, security)));
Trader.NewSecurities += securities => _securitiesWindow.SecurityPicker.Securities.AddRange(securities);
Trader.NewMyTrades += trades => _myTradesWindow.TradeGrid.Trades.AddRange(trades);
Trader.NewTrades += trades => _tradesWindow.TradeGrid.Trades.AddRange(trades);
Trader.NewOrders += orders => _ordersWindow.OrderGrid.Orders.AddRange(orders);
Trader.NewStopOrders += orders => _stopOrderWindow.OrderGrid.Orders.AddRange(orders);
Trader.OrdersRegisterFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str153)));
Trader.OrdersCancelFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2981)));
Trader.StopOrdersRegisterFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str153)));
Trader.StopOrdersCancelFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2981)));
Trader.NewPortfolios += portfolios => _portfoliosWindow.PortfolioGrid.Portfolios.AddRange(portfolios);
Trader.NewPositions += positions => _portfoliosWindow.PortfolioGrid.Positions.AddRange(positions);
Trader.MassOrderCancelFailed += (transId, error) =>
this.GuiAsync(() => MessageBox.Show(this, error.ToString(), LocalizedStrings.Str716));
// устанавливаем поставщик маркет-данных
_securitiesWindow.SecurityPicker.MarketDataProvider = Trader;
ShowSecurities.IsEnabled = ShowTrades.IsEnabled =
ShowMyTrades.IsEnabled = ShowOrders.IsEnabled =
ShowPortfolios.IsEnabled = ShowStopOrders.IsEnabled = ShowMyWin.IsEnabled = Console.IsEnabled = true;
}
Trader.Connect();
_isConnected = true;
ConnectBtn.Content = LocalizedStrings.Disconnect;
}
else
{
Trader.Disconnect();
_isConnected = false;
ConnectBtn.Content = LocalizedStrings.Connect;
}
}
static void Main(string[] args)
{
var tradeBufferMax = 200;
var depthBufferMax = 1000;
var tradeBuffers = new Dictionary <string, List <Trade> >();
var depthBuffers = new Dictionary <string, List <MarketDepth> >();
var tradeStorages = new Dictionary <string, IMarketDataStorage <Trade> >();
var depthStorages = new Dictionary <string, IMarketDataStorage <MarketDepth> >();
List <string> securityIds = new List <string>();
StorageFormats storageFormat;
string storagePath;
var settings = XElement.Load("settings.xml");
storagePath = @settings.Element("storage-path").Value;
storageFormat = (StorageFormats)Enum.Parse(typeof(StorageFormats), settings.Element("storage-format").Value.ToUpper());
foreach (var item in settings.Element("securities").Elements())
{
var secId = item.Element("security").Value;
securityIds.Add(secId);
depthBuffers.Add(secId, new List <MarketDepth>());
tradeBuffers.Add(secId, new List <Trade>());
}
var storage = new StorageRegistry()
{
DefaultDrive = new LocalMarketDataDrive {
Path = storagePath
}
};
var connector = new QuikTrader();
// Ставим false, чтобы квик при старте не загрузил все 30 тыс инструментов
connector.RequestAllSecurities = false;
// Контролируем соединение в течение работы срочного рынка
connector.ReConnectionSettings.WorkingTime = ExchangeBoard.Forts.WorkingTime;
// Обработчик события успешного соединения
connector.Connected += () =>
{
Console.WriteLine("Соединение установлено!");
if (securityIds.Any())
{
// Запрашиваем инструменты
foreach (var id in securityIds)
{
connector.LookupSecurities(new Security()
{
Code = id.Split('@')[0], Board = ExchangeBoard.GetBoard(id.Split('@')[1])
});
}
}
else
{
Console.WriteLine("Нет инструментов для запроса!");
}
};
connector.LookupSecuritiesResult += (ex, securities) =>
{
foreach (var security in securities)
{
if (tradeStorages.ContainsKey(security.Id) || depthStorages.ContainsKey(security.Id))
{
continue;
}
// Инициализируем специализированные хранилища
tradeStorages.Add(security.Id, storage.GetTradeStorage(security, null, storageFormat));
depthStorages.Add(security.Id, storage.GetMarketDepthStorage(security, null, storageFormat));
// Региструем получение сделок
if (!connector.RegisteredTrades.Contains(security))
{
connector.RegisterTrades(security);
}
// Региструем получение стаканов
if (!connector.RegisteredMarketDepths.Contains(security))
{
connector.RegisterMarketDepth(security);
}
}
};
connector.NewTrades += trades =>
{
foreach (var trade in trades)
{
var secId = trade.Security.Id;
tradeBuffers[secId].Add(trade);
if (tradeBuffers[secId].Count >= tradeBufferMax)
{
var forsave = tradeBuffers[secId].TakeLast(tradeBufferMax);
tradeBuffers[secId] = tradeBuffers[secId].Except(forsave).ToList();
var task = Task.Factory.StartNew(() => tradeStorages[secId].Save(forsave));
}
}
};
connector.MarketDepthsChanged += depths =>
{
foreach (var depth in depths)
{
var secId = depth.Security.Id;
depthBuffers[secId].Add(depth);
if (depthBuffers[secId].Count >= depthBufferMax)
{
var forsave = depthBuffers[secId].TakeLast(depthBufferMax);
depthBuffers[secId] = depthBuffers[secId].Except(forsave).ToList();
var task = Task.Factory.StartNew(() => depthStorages[secId].Save(forsave));
}
}
};
// Обработчик события разрыва соединения
connector.Disconnected += () => Console.WriteLine("Соединение разорвано!");
// Команда соединения
connector.Connect();
Console.Read();
var ttasks = new List <Task>();
var dtasks = new List <Task>();
foreach (var security in connector.Securities)
{
// Отменяем регистрацию сделок
if (connector.RegisteredTrades.Contains(security))
{
connector.UnRegisterTrades(security);
}
// Отменяем получение стаканов
if (connector.RegisteredMarketDepths.Contains(security))
{
connector.UnRegisterMarketDepth(security);
}
// Записываем остатки данных
ttasks.Add(Task.Factory.StartNew(() => tradeStorages[security.Id].Save(tradeBuffers[security.Id])));
dtasks.Add(Task.Factory.StartNew(() => depthStorages[security.Id].Save(depthBuffers[security.Id])));
}
Console.WriteLine("Записываем остатки данных!");
// Чуток ждем
Task.WaitAll(ttasks.ToArray());
Task.WaitAll(dtasks.ToArray());
// Команда разрыва соединения
connector.Disconnect();
}
private void ConnectClick(object sender, RoutedEventArgs e)
{
var isLua = IsLua.IsChecked == true;
if (isLua)
{
if (Address.Text.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2977);
return;
}
if (Login.Text.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2978);
return;
}
if (Password.Password.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2979);
return;
}
}
else
{
if (QuikPath.Folder.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2983);
return;
}
}
if (_trader == null)
{
// создаем подключение
_trader = isLua
? new QuikTrader
{
LuaFixServerAddress = Address.Text.To <EndPoint>(),
LuaLogin = Login.Text,
LuaPassword = Password.Password.To <SecureString>()
}
: new QuikTrader(QuikPath.Folder)
{
IsDde = true
};
if (_trader.IsDde)
{
_trader.DdeTables = new[] { _trader.SecuritiesTable, _trader.TradesTable };
}
_logManager.Sources.Add(_trader);
// подписываемся на событие об успешном восстановлении соединения
_trader.Restored += () => this.GuiAsync(() => MessageBox.Show(this, LocalizedStrings.Str2958));
// подписываемся на событие разрыва соединения
_trader.ConnectionError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString()));
// подписываемся на ошибку обработки данных (транзакций и маркет)
_trader.Error += error =>
this.GuiAsync(() => MessageBox.Show(this, error.ToString(), "Ошибка обработки данных"));
// подписываемся на ошибку подписки маркет-данных
_trader.MarketDataSubscriptionFailed += (security, type, error) =>
this.GuiAsync(() => MessageBox.Show(this, error.ToString(), LocalizedStrings.Str2956Params.Put(type, security)));
Security.SecurityProvider = new FilterableSecurityProvider(_trader);
_trader.Connect();
_candleManager = new CandleManager(_trader);
_candleManager.Processing += DrawCandle;
ConnectBtn.IsEnabled = false;
}
}
static void Main()
{
try
{
// для теста выбираем бумагу Лукойл
const string secCode = "LKOH";
var quikPath = QuikTerminal.GetDefaultPath();
if (quikPath.IsEmpty())
{
Console.WriteLine("Не найден ни один запущенный Quik");
return;
}
Console.WriteLine("Запущенный Quik найден по пути " + quikPath);
Console.Write("Введите код клиента, через который будет выставлена заявка: ");
var account = Console.ReadLine();
using (var waitHandle = new AutoResetEvent(false))
{
// создаем шлюз к Quik-у
using (var trader = new QuikTrader(quikPath))
{
// необходимо раскомментировать, если идет работа с РТС Стандарт
//trader.FormatTransaction += builder => builder.RemoveInstruction(TransactionBuilder.ExecutionCondition);
// подписываемся на событие успешного подключения
// все действия необходимо производить только после подключения
trader.Connected += () =>
{
Console.WriteLine("Подключение было произведено успешно.");
// извещаем об успешном соединени
waitHandle.Set();
};
Console.WriteLine("Производим подключение...");
trader.Connect();
// дожидаемся события об успешном соединении
waitHandle.WaitOne();
trader.NewPortfolios += portfolios =>
{
if (_portfolio == null)
{
// находим Лукойл и присваиваем ее переменной lkoh
_portfolio = portfolios.FirstOrDefault(p => p.Name == account);
if (_portfolio != null)
{
Console.WriteLine("Портфель {0} появился.", account);
// если инструмент и стакан уже появились,
// то извещаем об этом основной поток для выставления заявки
if (_lkoh != null && _depth != null)
{
waitHandle.Set();
}
}
}
};
// подписываемся на событие появление инструментов
trader.NewSecurities += securities =>
{
if (_lkoh == null)
{
// находим Лукойл и присваиваем ее переменной lkoh
_lkoh = securities.FirstOrDefault(sec => sec.Code == secCode);
if (_lkoh != null)
{
Console.WriteLine("Инструмент Лукойл появился.");
// запускаем экспорт стакана
trader.RegisterQuotes(_lkoh);
if (_portfolio != null && _depth != null)
{
waitHandle.Set();
}
}
}
};
// подписываемся на событие появления моих новых сделок
trader.NewMyTrades += myTrades =>
{
foreach (var myTrade in myTrades)
{
var trade = myTrade.Trade;
Console.WriteLine("Сделка {0} по цене {1} по бумаге {2} по объему {3} в {4}.", trade.Id, trade.Price, trade.Security.Code, trade.Volume, trade.Time);
}
};
// подписываемся на событие обновления стакана
trader.QuotesChanged += depths =>
{
if (_depth == null && _lkoh != null)
{
_depth = depths.FirstOrDefault(d => d.Security == _lkoh);
if (_depth != null)
{
Console.WriteLine("Стакан Лукойла появился.");
// если портфель и инструмент уже появился, то извещаем об этом основной поток для выставления заявки
if (_portfolio != null && _lkoh != null)
{
waitHandle.Set();
}
}
}
};
Console.WriteLine("Дожидаемся появления в программе инструмента Лукойл и портфеля {0}...".Put(account));
// запускаем экспорт по DDE
trader.StartExport(trader.SecuritiesTable, trader.MyTradesTable, trader.EquityPositionsTable,
trader.EquityPortfoliosTable, trader.OrdersTable);
// дожидаемся появления портфеля и инструмента
waitHandle.WaitOne();
// 0.1% от изменения цены
const decimal delta = 0.001m;
// запоминаем первоначальное значение середины спреда
var firstMid = _lkoh.BestPair.SpreadPrice / 2;
if (_lkoh.BestBid == null)
{
throw new Exception("Нет лучшего бида для котировки.");
}
Console.WriteLine("Первоначальное значение середины спреда {0:0.##}", _lkoh.BestBid.Price + firstMid);
while (true)
{
var mid = _lkoh.BestPair.SpreadPrice / 2;
// если спред вышел за пределы нашего диапазона
if (
((firstMid + firstMid * delta) <= mid) ||
((firstMid - firstMid * delta) >= mid)
)
{
var order = new Order
{
Portfolio = _portfolio,
Price = _lkoh.ShrinkPrice(_lkoh.BestBid.Price + mid),
Security = _lkoh,
Volume = 1,
Direction = OrderDirections.Buy,
};
trader.RegisterOrder(order);
Console.WriteLine("Заявка {0} зарегистрирована.", order.Id);
break;
}
else
{
Console.WriteLine("Текущее значение середины спреда {0:0.##}", _lkoh.BestBid.Price + mid);
}
// ждем 1 секунду
Thread.Sleep(1000);
}
// останавливаем экспорт по DDE
trader.StopExport(trader.SecuritiesTable, trader.MyTradesTable, trader.EquityPositionsTable,
trader.EquityPortfoliosTable, trader.OrdersTable);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private void ConnectClick(object sender, RoutedEventArgs e)
{
if (_trader == null || _trader.ConnectionState == ConnectionStates.Disconnected)
{
if (_trader == null)
{
if (Path.Text.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2983);
return;
}
// создаем подключение
_trader = new QuikTrader(Path.Text)
{
IsDde = true
};
Portfolios.Portfolios = new PortfolioDataSource(_trader);
_trader.Connected += () =>
{
_candleManager = new CandleManager(_trader);
_trader.NewSecurities += securities =>
{
// находим нужную бумагу
var lkoh = securities.FirstOrDefault(s => s.Code == "LKOH");
if (lkoh != null)
{
_lkoh = lkoh;
this.GuiAsync(() =>
{
Start.IsEnabled = true;
});
}
};
_trader.NewMyTrades += trades =>
{
if (_strategy != null)
{
// найти те сделки, которые совершила стратегия скользящей средней
trades = trades.Where(t => _strategy.Orders.Any(o => o == t.Order));
Trades.Trades.AddRange(trades);
}
};
_candleManager.Processing += (series, candle) =>
{
// если скользящие за сегодняшний день отрисованы, то рисуем в реальном времени текущие скользящие
if (_isTodaySmaDrawn && candle.State == CandleStates.Finished)
{
ProcessCandle(candle);
}
};
//_trader.Error += ex => this.GuiAsync(() => MessageBox.Show(this, ex.ToString()));
_trader.ConnectionError += ex =>
{
if (ex != null)
{
this.GuiAsync(() => MessageBox.Show(this, ex.ToString()));
}
};
this.GuiAsync(() =>
{
ConnectBtn.IsEnabled = false;
Report.IsEnabled = true;
});
};
}
_trader.Connect();
}
else
{
_trader.Disconnect();
}
}
private void ConnectClick(object sender, RoutedEventArgs e)
{
if (!_isConnected)
{
if (Path.Text.IsEmpty())
{
MessageBox.Show(this, "Путь к Quik не выбран");
}
else
{
if (Trader == null)
{
// создаем шлюз
Trader = new QuikTrader(Path.Text);
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Trader.SupportManualOrders = true;
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// возводим флаг, что соединение установлено
_isConnected = true;
// инициализируем механизм переподключения (будет автоматически соединяться
// каждые 10 секунд, если шлюз потеряется связь с сервером)
Trader.ReConnectionSettings.Interval = TimeSpan.FromSeconds(10);
// переподключение будет работать только во время работы биржи РТС
// (чтобы отключить переподключение когда торгов нет штатно, например, ночью)
Trader.ReConnectionSettings.WorkingTime = ExchangeBoard.Forts.WorkingTime;
// подписываемся на событие об успешном восстановлении соединения
Trader.ReConnectionSettings.ConnectionRestored += () => this.GuiAsync(() => MessageBox.Show(this, "Соединение восстановлено"));
// подписываемся на событие разрыва соединения
Trader.ConnectionError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString()));
Trader.NewSecurities += securities => this.GuiAsync(() => _securitiesWindow.Securities.AddRange(securities));
Trader.NewMyTrades += trades => this.GuiAsync(() => _myTradesWindow.Trades.AddRange(trades));
Trader.NewTrades += trades => this.GuiAsync(() => _tradesWindow.Trades.AddRange(trades));
Trader.NewOrders += orders => this.GuiAsync(() => _ordersWindow.Orders.AddRange(orders));
Trader.NewStopOrders += orders => this.GuiAsync(() => _stopOrderWindow.Orders.AddRange(orders));
Trader.NewPortfolios += portfolios => this.GuiAsync(() => _portfoliosWindow.Portfolios.AddRange(portfolios));
Trader.NewPositions += positions => this.GuiAsync(() => _positionsWindow.Positions.AddRange(positions));
Trader.ProcessDataError += ex => System.Diagnostics.Debug.WriteLine(ex);
Trader.Connected += () => this.GuiAsync(() =>
{
ExportDde.IsEnabled = true;
if (!Trader.IsExportStarted)
{
Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.MinStepPrice);
Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.Strike);
Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.OptionType);
Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.ExpiryDate);
Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.UnderlyingSecurity);
Trader.StartExport();
}
(new SoundPlayer(ConnectedSound)).Play();
});
ShowSecurities.IsEnabled = ShowTrades.IsEnabled =
ShowMyTrades.IsEnabled = ShowOrders.IsEnabled =
ShowPortfolios.IsEnabled = ShowStopOrders.IsEnabled = btnStart.IsEnabled = true;
}
Trader.Connect();
_isConnected = true;
ConnectBtn.Content = "Отключиться";
}
}
else
{
Trader.Disconnect();
_isConnected = false;
ConnectBtn.Content = "Подключиться";
}
}
static void Main()
{
try
{
// для теста выбираем бумагу Лукойл
const string secCode = "LKOH";
var quikPath = QuikTerminal.GetDefaultPath();
if (quikPath.IsEmpty())
{
Console.WriteLine(LocalizedStrings.Str2984);
return;
}
Console.WriteLine(LocalizedStrings.Str2985.Put(quikPath));
Console.Write(LocalizedStrings.Str2986);
var account = Console.ReadLine();
using (var waitHandle = new AutoResetEvent(false))
{
// создаем подключение к Quik-у
using (var trader = new QuikTrader(quikPath)
{
IsDde = true
})
{
// необходимо раскомментировать, если идет работа с РТС Стандарт
//trader.FormatTransaction += builder => builder.RemoveInstruction(Transaction.TimeInForce);
// подписываемся на событие успешного подключения
// все действия необходимо производить только после подключения
trader.Connected += () =>
{
Console.WriteLine(LocalizedStrings.Str2169);
// извещаем об успешном соединени
waitHandle.Set();
};
Console.WriteLine(LocalizedStrings.Str2170);
trader.DdeTables = new[] { trader.SecuritiesTable, trader.MyTradesTable, trader.EquityPositionsTable,
trader.EquityPortfoliosTable, trader.OrdersTable };
trader.Connect();
// дожидаемся события об успешном соединении
waitHandle.WaitOne();
trader.NewPortfolio += portfolio =>
{
if (_portfolio == null && portfolio.Name == account)
{
// находим нужный портфель и присваиваем его переменной _portfolio
_portfolio = portfolio;
Console.WriteLine(LocalizedStrings.Str2171Params, account);
// если инструмент и стакан уже появились,
// то извещаем об этом основной поток для выставления заявки
if (_lkoh != null && _depth != null)
{
waitHandle.Set();
}
}
};
// подписываемся на событие появление инструментов
trader.NewSecurity += security =>
{
if (_lkoh == null)
{
if (!security.Code.CompareIgnoreCase(secCode))
{
return;
}
// находим Лукойл и присваиваем ее переменной lkoh
_lkoh = security;
if (_lkoh != null)
{
Console.WriteLine(LocalizedStrings.Str2987);
// запускаем экспорт стакана
trader.RegisterMarketDepth(_lkoh);
if (_portfolio != null && _depth != null)
{
waitHandle.Set();
}
}
}
};
// подписываемся на событие появления моих новых сделок
trader.NewMyTrade += myTrade =>
{
var trade = myTrade.Trade;
Console.WriteLine(LocalizedStrings.Str2173Params, trade.Id, trade.Price, trade.Security.Code, trade.Volume, trade.Time);
};
// подписываемся на событие обновления стакана
trader.MarketDepthChanged += depth =>
{
if (_depth == null && _lkoh != null && depth.Security == _lkoh)
{
_depth = depth;
Console.WriteLine(LocalizedStrings.Str2988);
// если портфель и инструмент уже появился, то извещаем об этом основной поток для выставления заявки
if (_portfolio != null && _lkoh != null)
{
waitHandle.Set();
}
}
};
Console.WriteLine(LocalizedStrings.Str2989Params.Put(account));
// дожидаемся появления портфеля и инструмента
waitHandle.WaitOne();
// 0.1% от изменения цены
const decimal delta = 0.001m;
// запоминаем первоначальное значение середины спреда
var firstMid = _lkoh.BestPair.SpreadPrice / 2;
if (_lkoh.BestBid == null || firstMid == null)
{
throw new Exception(LocalizedStrings.Str2990);
}
Console.WriteLine(LocalizedStrings.Str2991Params, _lkoh.BestBid.Price + firstMid);
while (true)
{
var mid = _lkoh.BestPair.SpreadPrice / 2;
// если спред вышел за пределы нашего диапазона
if (mid != null &&
((firstMid + firstMid * delta) <= mid ||
(firstMid - firstMid * delta) >= mid)
)
{
var order = new Order
{
Portfolio = _portfolio,
Price = _lkoh.ShrinkPrice(_lkoh.BestBid.Price + mid.Value),
Security = _lkoh,
Volume = 1,
Direction = Sides.Buy,
};
trader.RegisterOrder(order);
Console.WriteLine(LocalizedStrings.Str1157Params, order.Id);
break;
}
else
{
Console.WriteLine(LocalizedStrings.Str2176Params, _lkoh.BestBid.Price + mid);
}
// ждем 1 секунду
Thread.Sleep(1000);
}
// останавливаем подключение
trader.Disconnect();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public void LuaConnect()
{
ManualResetEvent portfoliosWait = null;
if (!_isConnected)
{
if (_fixServerAddress.IsEmpty())
{
MessageBox.Show(LocalizedStrings.Str2977);
return;
}
if (_luaLogin.IsEmpty())
{
MessageBox.Show(LocalizedStrings.Str2978);
return;
}
if (_luaPassword.IsEmpty())
{
MessageBox.Show(LocalizedStrings.Str2979);
return;
}
if (Trader == null)
{
// создаем подключение
Trader = new QuikTrader
{
LuaFixServerAddress = _fixServerAddress.To <EndPoint>(),
LuaLogin = _luaLogin,
LuaPassword = _luaPassword.To <SecureString>()
};
Trader.LogLevel = LogLevels.Debug;
_logManager.Sources.Add(Trader);
// отключение автоматического запроса всех инструментов.
//Trader.RequestAllSecurities = AllSecurities.IsChecked == true;
Trader.RequestAllSecurities = true;
// возводим флаг, что соединение установлено
_isConnected = true;
// переподключение будет работать только во время работы биржи РТС
// (чтобы отключить переподключение когда торгов нет штатно, например, ночью)
Trader.ReConnectionSettings.WorkingTime = ExchangeBoard.Forts.WorkingTime;
// подписываемся на событие об успешном восстановлении соединения
Trader.Restored += () => MessageBox.Show(LocalizedStrings.Str2958);
// подписываемся на событие разрыва соединения
Trader.ConnectionError += error => MessageBox.Show(error.ToString());
// подписываемся на ошибку обработки данных (транзакций и маркет)
//Trader.Error += error =>
// this.GuiAsync(() => MessageBox.Show(this, error.ToString(), "Ошибка обработки данных"));
// подписываемся на ошибку подписки маркет-данных
Trader.MarketDataSubscriptionFailed += (security, type, error) => MessageBox.Show(error.ToString(), LocalizedStrings.Str2956Params.Put(type, security));
Trader.NewSecurities += TraderOnNewSecurities;
Trader.LookupSecuritiesResult += TraderOnLookupSecuritiesResult;
//Trader.NewMyTrades += trades => _myTradesWindow.TradeGrid.Trades.AddRange(trades);
//Trader.NewTrades += trades => _tradesWindow.TradeGrid.Trades.AddRange(trades);
//Trader.NewOrders += orders => _ordersWindow.OrderGrid.Orders.AddRange(orders);
//Trader.NewStopOrders += orders => _stopOrderWindow.OrderGrid.Orders.AddRange(orders);
//Trader.OrdersRegisterFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2960)));
//Trader.OrdersCancelFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2981)));
//Trader.StopOrdersRegisterFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2960)));
//Trader.StopOrdersCancelFailed += fails => fails.ForEach(fail => this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2981)));
//Trader.NewPortfolios += portfolios => _portfoliosWindow.PortfolioGrid.Portfolios.AddRange(portfolios);
//Trader.NewPositions += positions => _portfoliosWindow.PortfolioGrid.Positions.AddRange(positions);
// устанавливаем поставщик маркет-данных
//_securitiesWindow.SecurityPicker.MarketDataProvider = Trader;
//ShowSecurities.IsEnabled = ShowTrades.IsEnabled =
// ShowMyTrades.IsEnabled = ShowOrders.IsEnabled =
// ShowPortfolios.IsEnabled = ShowStopOrders.IsEnabled = true;
portfoliosWait = new ManualResetEvent(false);
Action <IEnumerable <Portfolio> > newPortfolios = portfolios =>
{
if (_portfolio1 == null)
{
Portfolio first = null;
foreach (Portfolio p in portfolios)
{
if (p.Name == "60087")
{
first = p;
break;
}
}
_portfolio1 = first;
}
// если оба инструмента появились
if (_portfolio1 != null)
{
portfoliosWait.Set();
}
};
Trader.NewPortfolios += newPortfolios;
decimal sum;
sum = 0.0m;
foreach (var portfolio in Trader.Portfolios)
{
sum += portfolio.GetFreeMoney(false);
}
Debug.WriteLine(sum.ToString());
}
Trader.Connect();
_isConnected = true;
Debug.WriteLine(Trader.ConnectionState.ToString());
portfoliosWait.WaitOne();
GetAllSecurities();
Debug.WriteLine(Trader.ConnectionState.ToString());
}
else
{
Trader.Disconnect();
_isConnected = false;
Debug.WriteLine(Trader.ConnectionState.ToString());
}
}
public bool Connect(Terminal toTerminal)
{
try
{
if (Trader == null)
{
// создаем подключение
Trader = new QuikTrader {
IsDde = false, Path = toTerminal.FullPath
};
/*
* {
* LuaFixServerAddress = Address.Text.To<EndPoint>(),
* LuaLogin = Login.Text,
* LuaPassword = Password.Password.To<SecureString>()
* };
*/
Trader.LogLevel = LogLevels.Info;
_logManager.Sources.Add(Trader);
_logManager.Listeners.Add(new FileLogListener("XTrade.Quik.log"));
// отключение автоматического запроса всех инструментов.
Trader.RequestAllSecurities = false;
// возводим флаг, что соединение установлено
_isConnected = true;
// переподключение будет работать только во время работы биржи РТС
// (чтобы отключить переподключение когда торгов нет штатно, например, ночью)
Trader.ReConnectionSettings.WorkingTime = ExchangeBoard.Forts.WorkingTime;
// подписываемся на событие об успешном восстановлении соединения
Trader.Restored += () =>
{
Log("Connection restored");
}; // MessageBox.Show(this, LocalizedStrings.Str2958));
// подписываемся на событие разрыва соединения
Trader.ConnectionError += error =>
{
Log(error.ToString());
}; //this.GuiAsync(() => MessageBox.Show(this, error.ToString()));
// подписываемся на ошибку обработки данных (транзакций и маркет)
Trader.Error += error => { Log(error.ToString()); };
// this.GuiAsync(() => MessageBox.Show(this, error.ToString(), "Ошибка обработки данных"));
// подписываемся на ошибку подписки маркет-данных
Trader.MarketDataSubscriptionFailed += (security, msg, error) => { Log(error.ToString()); };
// this.GuiAsync(() => MessageBox.Show(this, error.ToString(), LocalizedStrings.Str2956Params.Put(msg.DataType, security)));
Trader.NewSecurity += Securities.Add;
//Trader.NewMyTrade += _myTradesWindow.TradeGrid.Trades.Add;
//Trader.NewTrade += _tradesWindow.TradeGrid.Trades.Add;
Trader.NewOrder += Orders.Add;
Trader.NewStopOrder += Orders.Add;
//Trader.OrderRegisterFailed += _ordersWindow.OrderGrid.AddRegistrationFail;
//Trader.StopOrderRegisterFailed += _stopOrdersWindow.OrderGrid.AddRegistrationFail;
Trader.OrderCancelFailed += fail => { Log(fail.Error.Message); };
// this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2981));
Trader.StopOrderCancelFailed += fail => { Log(fail.Error.Message); };
//this.GuiAsync(() => MessageBox.Show(this, fail.Error.Message, LocalizedStrings.Str2981));
Trader.NewPortfolio += Portfolios.Add;
Trader.NewPosition += Positions.Add;
Trader.MassOrderCancelFailed += (transId, error) => { Log(error.ToString()); };
//this.GuiAsync(() => MessageBox.Show(this, error.ToString(), LocalizedStrings.Str716));
// устанавливаем поставщик маркет-данных
// _securitiesWindow.SecurityPicker.MarketDataProvider = Trader;
//ShowSecurities.IsEnabled = ShowTrades.IsEnabled =
// ShowMyTrades.IsEnabled = ShowOrders.IsEnabled =
// ShowPortfolios.IsEnabled = ShowStopOrders.IsEnabled = true;
Trader.Connect();
_isConnected = true;
bStopJobs = false;
terminal = toTerminal;
//var advs = MainService.thisGlobal.GetAdvisersByTerminal(terminal.Id);
Portfolio portfolio = null;
try
{
var res = service.GetAdvisers().Where(x => x.TerminalId == toTerminal.Id);
foreach (var adv in res)
{
if (!adv.Disabled)
{
QUIKExpert quikE = new QUIKExpert(adv);
advisers.Add(adv.Id, quikE);
service.SubscribeToSignals(adv.Id);
if (string.IsNullOrEmpty(adv.State))
{
adv.State = quikE.Serialize();
service.UpdateAdviser(adv);
}
if (portfolio == null)
{
portfolio = Portfolios.Where(x => x.Name == quikE.PortfolioName).FirstOrDefault();
}
}
}
Log("Successfully connected to <QUIK>");
}
catch (Exception e)
{
log.Error(e);
}
return(true);
}
Trader.Disconnect();
_isConnected = false;
return(false);
}
catch (Exception e)
{
Log(e.ToString());
}
return(false);
}
static void Main()
{
try
{
Console.Write(LocalizedStrings.Str2992);
var account1 = Console.ReadLine();
Console.Write(LocalizedStrings.Str2993);
var account2 = Console.ReadLine();
using (var quikTrader1 = new QuikTrader {
LuaFixServerAddress = "127.0.0.1:5001".To <EndPoint>()
})
using (var quikTrader2 = new QuikTrader {
LuaFixServerAddress = "127.0.0.1:5002".To <EndPoint>()
})
{
// подписываемся на событие ошибок обработки данных и разрыва соединения
//
quikTrader1.Error += OnError;
quikTrader2.Error += OnError;
quikTrader1.ConnectionError += OnError;
quikTrader2.ConnectionError += OnError;
var portfoliosWait = new ManualResetEvent(false);
Action <IEnumerable <Portfolio> > newPortfolios = portfolios =>
{
if (_portfolio1 == null)
{
_portfolio1 = portfolios.FirstOrDefault(p => p.Name == account1);
}
if (_portfolio2 == null)
{
_portfolio2 = portfolios.FirstOrDefault(p => p.Name == account2);
}
// если оба инструмента появились
if (_portfolio1 != null && _portfolio2 != null)
{
portfoliosWait.Set();
}
};
// подписываемся на события новых портфелей
quikTrader1.NewPortfolios += newPortfolios;
quikTrader2.NewPortfolios += newPortfolios;
var securitiesWait = new ManualResetEvent(false);
// подписываемся на события новых инструментов
quikTrader1.NewSecurities += securities =>
{
if (_lkoh == null)
{
_lkoh = securities.FirstOrDefault(s => s.Code == "LKOH");
}
// если оба инструмента появились
if (_lkoh != null && _riz0 != null)
{
securitiesWait.Set();
}
};
quikTrader2.NewSecurities += securities =>
{
if (_riz0 == null)
{
_riz0 = securities.FirstOrDefault(s => s.Code == "RIZ0");
}
// если оба инструмента появились
if (_lkoh != null && _riz0 != null)
{
securitiesWait.Set();
}
};
// запускаем экспорты в Quik-ах, когда получим событие об успешном соединении
//
quikTrader1.Connected += () =>
{
Console.WriteLine(LocalizedStrings.Str2994Params.Put(quikTrader1.LuaFixServerAddress));
};
quikTrader2.Connected += () =>
{
Console.WriteLine(LocalizedStrings.Str2994Params.Put(quikTrader2.LuaFixServerAddress));
};
// производим подключение каждого из QuikTrader-а
//
quikTrader1.Connect();
quikTrader2.Connect();
Console.WriteLine(LocalizedStrings.Str2995);
portfoliosWait.WaitOne();
securitiesWait.WaitOne();
Console.WriteLine(LocalizedStrings.Str2996);
if (_lkoh.BestBid == null || _riz0.BestBid == null)
{
throw new Exception(LocalizedStrings.Str2990);
}
quikTrader1.RegisterOrder(new Order
{
Portfolio = _portfolio1,
Volume = 1,
Security = _lkoh,
Price = _lkoh.BestBid.Price
});
Console.WriteLine(LocalizedStrings.Str2997);
quikTrader2.RegisterOrder(new Order
{
Portfolio = _portfolio2,
Volume = 1,
Security = _riz0,
Price = _riz0.BestBid.Price
});
Console.WriteLine(LocalizedStrings.Str2998);
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
private void ConnectClick(object sender, RoutedEventArgs e)
{
if (!_isConnected)
{
if (Path.Text.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2969);
}
else
{
if (Trader == null)
{
// создаем подключение
Trader = new QuikTrader(Path.Text)
{
IsDde = true
};
// возводим флаг, что соединение установлено
_isConnected = true;
// подписываемся на событие ошибки соединения
Trader.ConnectionError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString()));
Trader.NewSecurities += securities => _securitiesWindow.SecurityPicker.Securities.AddRange(securities);
Trader.Error += error => System.Diagnostics.Debug.WriteLine(error);
// добавляем на экспорт необходимые колонки
Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.ImpliedVolatility);
Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.TheorPrice);
Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.UnderlyingSecurity);
Trader.SecuritiesTable.Columns.Add(DdeSecurityColumns.StepPrice);
// добавляем экспорт дополнительных колонок из стакана (своя продажа и покупка)
Trader.QuotesTable.Columns.Add(DdeQuoteColumns.OwnAskVolume);
Trader.QuotesTable.Columns.Add(DdeQuoteColumns.OwnBidVolume);
Trader.DdeTables = new[] { Trader.SecuritiesTable };
Trader.Connected += () => this.GuiAsync(() =>
{
ShowSecurities.IsEnabled = true;
_isConnected = true;
ConnectBtn.Content = LocalizedStrings.Disconnect;
});
Trader.Disconnected += () => this.GuiAsync(() =>
{
_isConnected = false;
ConnectBtn.Content = LocalizedStrings.Connect;
});
}
Trader.Connect();
}
}
else
{
Trader.Disconnect();
}
}
private void CreateConnector(Configuration config)
{
try
{
if (Connector != null && Connector.ConnectionState == ConnectionStates.Connected)
{
throw new Exception("Нельзя создать новый коннектор при активном соединении.");
}
if (Connector != null)
{
if (LogManager.Sources.Contains(Connector))
{
LogManager.Sources.Remove(Connector);
}
Connector.Dispose();
}
switch (config.ConnectorType)
{
case eConnectorType.SmartCom:
if (config.SmartAddress == null)
{
throw new Exception("Не задан адрес сервера SmartCom.");
}
if (config.SmartAddress.IsEqual(SmartComAddresses.Demo) && (string.IsNullOrWhiteSpace(config.SmartDemo.Login) || string.IsNullOrWhiteSpace(config.SmartDemo.Password)))
{
this.AddWarningLog(string.Format("{0}", "Не заданы логин и/или пароль демо-счета SmartCom"));
OnNewStatusMessage("Не заданы логин и/или пароль для демо-счета SmartCom!");
return;
}
if (!config.SmartAddress.IsEqual(SmartComAddresses.Demo) && (string.IsNullOrWhiteSpace(config.SmartLive.Login) || string.IsNullOrWhiteSpace(config.SmartLive.Password)))
{
this.AddWarningLog(string.Format("{0}", "Не заданы логин и/или пароль SmartCom"));
OnNewStatusMessage("Не заданы логин и/или пароль SmartCom!");
return;
}
Connector = new SmartTrader();
((SmartTrader)Connector).Address = config.SmartAddress;
((SmartTrader)Connector).Version = SmartComVersions.V3;
if (config.SmartAddress.IsEqual(SmartComAddresses.Demo))
{
((SmartTrader)Connector).Login = config.SmartDemo.Login;
((SmartTrader)Connector).Password = config.SmartDemo.Password;
}
else
{
((SmartTrader)Connector).Login = config.SmartLive.Login;
((SmartTrader)Connector).Password = config.SmartLive.Password;
}
break;
case eConnectorType.Quik:
Connector = new QuikTrader
{
LuaLogin = config.LuaLogin,
LuaFixServerAddress = config.LuaFixServerAddress
};
break;
default:
break;
}
ConnectorType = config.ConnectorType;
if (!LogManager.Sources.Contains(Connector))
{
LogManager.Sources.Add(Connector);
}
OnConnectorCreated(Connector, config.ConnectorType);
this.AddWarningLog(string.Format("Создан новый коннектор {0}", config.ConnectorType.ToString()));
OnNewStatusMessage(string.Format("Создан новый коннектор {0}", config.ConnectorType.ToString()));
}
catch (Exception ex)
{
this.AddErrorLog(string.Format("{0} / {1}", ex.Message, ex.StackTrace));
OnNewStatusMessage(ex.Message);
}
}
private void ConnectClick(object sender, RoutedEventArgs e)
{
if (!_isConnected)
{
if (Path.Text.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2969);
}
else
{
if (Trader == null)
{
// создаем подключение
Trader = new QuikTrader(Path.Text)
{
IsDde = true
};
// возводим флаг, что соединение установлено
_isConnected = true;
// подписываемся на событие ошибки соединения
Trader.ConnectionError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString()));
// добавляем тип QuikCandle для преобразования строчки из таблица Исторические свечи в объект QuikCandle
_table = new DdeCustomTable(typeof(QuikCandle));
Trader.CustomTables.Add(_table);
Trader.NewCustomTables += (type, objects) =>
{
// нас интересует только QuikCandle
if (type == typeof(QuikCandle))
{
_candlesWindow.Candles.AddRange(objects.Cast <QuikCandle>());
}
};
Trader.Connected += () => this.GuiAsync(() =>
{
ShowCandles.IsEnabled = true;
ExportDde.IsEnabled = true;
_isConnected = true;
ConnectBtn.Content = LocalizedStrings.Disconnect;
});
Trader.Disconnected += () => this.GuiAsync(() =>
{
_isConnected = false;
ConnectBtn.Content = LocalizedStrings.Connect;
});
}
Trader.Connect();
}
}
else
{
Trader.Disconnect();
}
}
private void ConnectClick(object sender, RoutedEventArgs e)
{
if (_connector == null)
{
if (IsQuik.IsChecked == true)
{
var isDde = IsDde.IsChecked == true;
if (isDde && Path.Text.IsEmpty())
{
MessageBox.Show(this, LocalizedStrings.Str2969);
return;
}
// создаем подключение
var trader = new QuikTrader(Path.Text)
{
IsDde = isDde
};
if (isDde)
{
// изменяем метаданные так, чтобы начали обрабатывать дополнительные колонки опционов
var columns = trader.SecuritiesTable.Columns;
columns.Add(DdeSecurityColumns.Strike);
columns.Add(DdeSecurityColumns.ImpliedVolatility);
columns.Add(DdeSecurityColumns.UnderlyingSecurity);
columns.Add(DdeSecurityColumns.TheorPrice);
columns.Add(DdeSecurityColumns.OptionType);
columns.Add(DdeSecurityColumns.ExpiryDate);
}
_connector = trader;
}
else
{
var trader = new PlazaTrader
{
Address = Address.Text.To <EndPoint>(),
IsCGate = IsCGate.IsChecked == true
};
trader.Tables.Add(trader.TableRegistry.Volatility);
if (IsAutorization.IsChecked == true)
{
trader.Login = Login.Text;
trader.Password = Password.Password;
}
_connector = trader;
}
Desk.MarketDataProvider = _connector;
Desk.SecurityProvider = _connector;
Desk.CurrentTime = null;
// добавляем в выпадающий список только фьючерсы
_connector.NewSecurities += securities =>
this.GuiAsync(() =>
{
_assets.AddRange(securities.Where(s => s.Type == SecurityTypes.Future));
if (SelectedAsset == null && _assets.Count > 0)
{
SelectedAsset = _assets.First();
}
if (SelectedAsset != null)
{
var newStrikes = securities
.Where(s => s.Type == SecurityTypes.Option && s.UnderlyingSecurityId.CompareIgnoreCase(SelectedAsset.Id))
.ToArray();
if (newStrikes.Length > 0)
{
_options.AddRange(newStrikes);
Desk.Options = _options;
Desk.RefreshOptions();
}
}
});
_connector.SecuritiesChanged += securities =>
{
this.GuiAsync(() =>
{
if (SelectedAsset == null)
{
return;
}
var newStrikes = securities
.Where(s => s.Type == SecurityTypes.Option && s.UnderlyingSecurityId.CompareIgnoreCase(SelectedAsset.Id))
.Where(s => !_options.Contains(s))
.ToArray();
if (newStrikes.Length > 0)
{
_options.AddRange(newStrikes);
Desk.Options = _options;
Desk.RefreshOptions();
}
if (Desk.Options.Intersect(securities).Any())
{
Desk.RefreshOptions();
}
});
};
// подписываемся на событие новых сделок чтобы обновить текущую цену фьючерса
_connector.NewTrades += trades => this.GuiAsync(() =>
{
var asset = SelectedAsset;
if (asset == null)
{
return;
}
if (asset.LastTrade != null)
{
LastPrice.Text = asset.LastTrade.Price.To <string>();
}
});
_connector.Connected += () =>
{
var trader = _connector as QuikTrader;
if (trader != null && trader.IsDde)
{
var quikTrader = trader;
quikTrader.StartExport(new[] { quikTrader.SecuritiesTable, quikTrader.TradesTable });
}
else
{
_connector.StartExport();
}
};
}
if (_connector.ConnectionState == ConnectionStates.Connected)
{
_connector.Disconnect();
}
else
{
_connector.Connect();
}
}
