private void intervalCb_SelectionChanged(object sender, SelectionChangedEventArgs e) { if (intervalCb.SelectedItem != null) { string selectedstring = (string)intervalCb.SelectedItem; CandleInterval intervalToUse = CandleInterval.Day1; if (selectedstring == "1 Minute") { intervalToUse = CandleInterval.Minute1; } else if (selectedstring == "5 Minutes") { intervalToUse = CandleInterval.Minutes5; } else if (selectedstring == "1 Hour") { intervalToUse = CandleInterval.Hour1; } else if (selectedstring == "1 Day") { intervalToUse = CandleInterval.Day1; } LoadChart(coinsCb.SelectedItem.ToString(), intervalToUse); } }
public async Task <bool> IsSubscribed(string classCode, string securityCode, CandleInterval interval) { var message = new Message <string>(classCode + "|" + securityCode + "|" + (int)interval, "is_subscribed"); Message <bool> response = await QuikService.Send <Message <bool> >(message); return(response.Data); }
public async Task <ApiResponse> StockCandles(string code, DateTime from, CandleInterval interval) { var dateString = from.ToString("yyyy-MM-dd"); var url = $"http://iss.moex.com/iss/engines/stock/markets/shares/securities/{code}/candles.json?from={dateString}&interval={(int)interval}&iss.meta=off"; return(await RequestTo(url)); }
public static CandlePeriod ToOuterFormat(CandleInterval candleInterval) { switch (candleInterval) { case CandleInterval.Minute: return(CandlePeriod.Minute1); case CandleInterval.ThreeMinutes: return(CandlePeriod.Minute3); case CandleInterval.FiveMinutes: return(CandlePeriod.Minute5); case CandleInterval.QuarterHour: return(CandlePeriod.Minute15); case CandleInterval.HalfHour: return(CandlePeriod.Minute30); case CandleInterval.Hour: return(CandlePeriod.Hour1); case CandleInterval.Day: return(CandlePeriod.Day1); case CandleInterval.Week: return(CandlePeriod.Day7); case CandleInterval.Month: return(CandlePeriod.Month1); default: throw new ConnectorException("Undefined candle period", null); } }
public static string ConvertToString(this CandleInterval interval) { switch (interval) { case CandleInterval.Minute: return("1MIN"); case CandleInterval.Minutes5: return("5MIN"); case CandleInterval.Minutes15: return("15MIN"); case CandleInterval.Minutes30: return("30MIN"); case CandleInterval.Hour: return("1HR"); case CandleInterval.Day: return("1D"); default: return("unexpected"); } }
public Settings() { robotMode = "Виртуальный"; lifeTimeOrder = "00:01:00"; tF = CandleInterval.M1; koefSlip = 1; qtyOrder = 5000; periodPriceChnl = 5; }
public SubscribeCandleMessage(string figi, CandleInterval interval) { if (string.IsNullOrWhiteSpace(figi)) { throw new ArgumentNullException(nameof(figi)); } Figi = figi; Interval = interval; }
public async Task <CandlesResponse> GetCandles(string symbol, CandleInterval interval, DateTime start, DateTime end, int limit) { IDictionary <string, object> form = new Dictionary <string, object>(3) { ["start"] = UnixTime.Get(start), ["end"] = UnixTime.Get(end), ["limit"] = limit }; return(await this.Send <CandlesResponse>($"/klines/{symbol}/{this.ConvertToString(interval)}")); }
public override async Task <ExecutionResult> RunAsync(IStepExecutionContext context) { var req = StreamingRequest.SubscribeCandle( "BBG006L8G4H1" /* YNDX */, CandleInterval.Minute() ); await Proxy.SendStreamingRequestAsync(req); Console.WriteLine($"{nameof(RunWatchers)} - OK."); return(ExecutionResult.Next()); }
public async Task <CandleList> MarketCandlesAsync(string figi, DateTime from, DateTime to, CandleInterval interval) { var endpoint = AppendQueryParams(Endpoints.MarketCandles, ("figi", figi), ("from", FormatDateTime(from)), ("to", FormatDateTime(to)), ("interval", interval.GetEnumMemberValue())); var response = await Connection.SendGetRequestAsync <CandleList>(endpoint) .ConfigureAwait(false); return(response?.Payload); }
public string ConvertToString(CandleInterval candleInterval) { switch (candleInterval) { case CandleInterval.None: return(string.Empty); case CandleInterval.OneMinute: return("1m"); case CandleInterval.FiveMinutes: return("5m"); case CandleInterval.FifteenMinutes: return("15m"); case CandleInterval.ThirtyMinutes: return("30m"); case CandleInterval.OneHour: return("1h"); case CandleInterval.TwoHours: return("2h"); case CandleInterval.FourHours: return("4h"); case CandleInterval.EightHours: return("8h"); case CandleInterval.TwelveHours: return("12h"); case CandleInterval.OneDay: return("1d"); case CandleInterval.OneWeek: return("1w"); case CandleInterval.OneMonth: return("1m"); case CandleInterval.OneYear: return("1y"); default: return(string.Empty); } }
public static TimeSpan GetMaxPeriod(CandleInterval interval) { return(interval switch { CandleInterval.Minute => TimeSpan.FromDays(1), CandleInterval.FiveMinutes => TimeSpan.FromDays(1), CandleInterval.QuarterHour => TimeSpan.FromDays(1), CandleInterval.HalfHour => TimeSpan.FromDays(1), CandleInterval.Hour => TimeSpan.FromDays(7).Add(TimeSpan.FromHours(-1)), CandleInterval.Day => TimeSpan.FromDays(364), CandleInterval.Week => TimeSpan.FromDays(364 * 2), CandleInterval.Month => TimeSpan.FromDays(364 * 10), _ => throw new KeyNotFoundException(), });
async Task GetQuotation(Tool instrument, CandleInterval tf) { List <Candle> AllCandles; string InstrID; toolCandles = new DataSet(); try { bool _isSubscribed = false; while (!_isSubscribed) { textBoxLogs.AppendText("Подписываемся на получение свечек: " + instrument.ClassCode + "|" + instrument.SecurityCode + "|" + tf + "..." + Environment.NewLine); _quik.Candles.Subscribe(instrument.ClassCode, instrument.SecurityCode, tf).Wait(); textBoxLogs.AppendText("Проверяем состояние подписки" + "..." + Environment.NewLine); _isSubscribed = _quik.Candles.IsSubscribed(instrument.ClassCode, instrument.SecurityCode, tf).Result; } textBoxLogs.AppendText("Подписка включена" + "..." + Environment.NewLine); textBoxLogs.AppendText("Получаем таблицу свечей" + "..." + Environment.NewLine); AllCandles = await _quik.Candles.GetAllCandles(instrument.ClassCode, instrument.SecurityCode, tf).ConfigureAwait(false); InstrID = instrument.ClassCode + "|" + instrument.SecurityCode + "|" + tf; if (toolCandles.Tables[InstrID] == null && AllCandles.Count > 1) { try { toolCandles.Tables.Add(AllCandles_to_Table(AllCandles, InstrID)); toolCandles.Tables[InstrID].Columns["DateTime"].SetOrdinal(0); toolCandles.Tables[InstrID].Columns["Open"].SetOrdinal(1); toolCandles.Tables[InstrID].Columns["High"].SetOrdinal(2); toolCandles.Tables[InstrID].Columns["Low"].SetOrdinal(3); toolCandles.Tables[InstrID].Columns["Close"].SetOrdinal(4); toolCandles.Tables[InstrID].Columns["Volume"].SetOrdinal(5); textBoxLogs.AppendText("Сформирована таблица котировок для: " + InstrID + ". Количество свечек = " + AllCandles.Count + "..." + Environment.NewLine); } catch { textBoxLogs.AppendText("Не удалось сформировать таблицу котировок для: " + InstrID + "..." + Environment.NewLine); } } _quik.Candles.NewCandle += OnNewCandle; } catch { textBoxLogs.AppendText("Ошибка подписки на инструмент." + Environment.NewLine); } }
/// <summary> /// /// </summary> /// <param name="client"></param> /// <param name="symbol"></param> /// <param name="interval"></param> /// <param name="limit"></param> /// <param name="token"></param> /// <returns></returns> public static async Task <string> GetLatestCandlesAsync(this ICryptocoreHttpClient client, Symbol symbol, CandleInterval interval, int limit = 100, CancellationToken token = default) { Throw.IfNull(client, nameof(client)); Throw.IfNull(symbol, nameof(symbol)); var request = new CryptocoreHttpRequest($"/v1/data/ohlcv/{symbol}/latest"); request.AddParameter("period_id", interval.ConvertToString()); if (limit > 0) { request.AddParameter("limit", limit); } return(await client.GetAsync(request, token) .ConfigureAwait(false)); }
public CandlePayload(string figi, [JsonProperty("o")] double open, [JsonProperty("c")] double close, [JsonProperty("h")] double high, [JsonProperty("l")] double low, [JsonProperty("v")] double volume, DateTimeOffset time, CandleInterval interval) { Figi = figi; Open = open; Close = close; High = high; Low = low; Volume = volume; Time = time; Interval = interval; }
public CandlePayload( [JsonProperty("o")] decimal open, [JsonProperty("c")] decimal close, [JsonProperty("h")] decimal high, [JsonProperty("l")] decimal low, [JsonProperty("v")] decimal volume, DateTime time, CandleInterval interval, string figi) { Open = open; Close = close; High = high; Low = low; Volume = volume; Time = time; Interval = interval; Figi = figi; }
public CandlePayload( decimal open, decimal close, decimal high, decimal low, decimal volume, DateTime time, CandleInterval interval, string figi) { Open = open; Close = close; High = high; Low = low; Volume = volume; Time = time; Interval = interval; Figi = figi; }
/// <summary> /// /// </summary> /// <param name="client"></param> /// <param name="symbol"></param> /// <param name="interval"></param> /// <param name="start"></param> /// <param name="end"></param> /// <param name="token"></param> /// <returns></returns> public static async Task <string> GetHistoricalCandlesAsync(this ICryptocoreHttpClient client, Symbol symbol, CandleInterval interval, DateTime start, DateTime end = default, CancellationToken token = default) { Throw.IfNull(client, nameof(client)); Throw.IfNull(symbol, nameof(symbol)); var request = new CryptocoreHttpRequest($"/v1/data/ohlcv/{symbol}/history"); request.AddParameter("period_id", interval.ConvertToString()); request.AddParameter("time_start", start.ToTimestamp()); if (end != default) { request.AddParameter("time_end", end.ToTimestamp()); } return(await client.GetAsync(request, token) .ConfigureAwait(false)); }
public static CandleRequest UnsubscribeCandle(string figi, CandleInterval interval) => CandleRequest.Unsubscribe(figi, interval);
private void LoadSettings() { disableEvents = true; cbCandleIntervall.SelectedItem = (CandleInterval)Settings.getInt(SettKeys.CANDLE_INTERVALL); candleInter = (CandleInterval)Settings.getInt(SettKeys.CANDLE_INTERVALL); if (candleInter <= 0) candleInter = CandleInterval._1h; nudMaxChartPoints.Value = Settings.getInt(SettKeys.MAX_CHART_POINTS); foreach (string key in Settings.Data.Keys) { if (key.StartsWith(Lib.Const.IDS.TEXTBOX)) { string tbname = key.Substring(Lib.Const.IDS.TEXTBOX.Length); Control[] tb = this.Controls.Find(tbname, true); foreach (Control item in tb) { item.Text = Lib.Converter.toString(Settings.Data[key]); } } else if (key.StartsWith(Lib.Const.IDS.CHECKBOX)) { string tbname = key.Substring(Lib.Const.IDS.CHECKBOX.Length); Control[] tb = this.Controls.Find(tbname, true); foreach (Control item in tb) { if (item is CheckBox) { ((CheckBox)item).Checked = Settings.getBool(key); } } } } if (cbAutoLoadTickerApi.Checked) { bApiLoad_Click(null, null); } if (cbAutoLoadTrader.Checked) { bReloadTrader_Click(null, null); } if (cbAutoLoadSimPorto.Checked) { bSetSimPorto_Click(null, null); } disableEvents = false; }
private void changeCandleIntervall(CandleInterval newintervall) { if (newintervall == candleInter) return; candleInter = newintervall; if (tr != null) tr.init(kh, candleInter, cm); cm.CandleList[(int)candleInter].setCandleEventHandler(new NewCandleEventHandler(OnNewCandleReceived)); Settings.set(SettKeys.CANDLE_INTERVALL, (int)candleInter); }
public Indikators(CandleManager cm, CandleInterval defaultci) { this._cm = cm; this._defaultci = defaultci; }
public async Task <List <StockCandle> > StockCandles(string ticket, DateTime from, CandleInterval interval) { var data = await _marketData.GetStockCandleData(ticket, from, interval); var openIndex = data.candles.columns.IndexOf("open"); var closeIndex = data.candles.columns.IndexOf("close"); var highIndex = data.candles.columns.IndexOf("high"); var lowIndex = data.candles.columns.IndexOf("low"); var valueIndex = data.candles.columns.IndexOf("value"); var volumeIndex = data.candles.columns.IndexOf("volume"); var dateTimeIndex = data.candles.columns.IndexOf("begin"); var candles = new List <StockCandle>(); foreach (var candleData in data.candles.data) { candles.Add(new StockCandle() { Open = candleData[openIndex].GetDouble(), Close = candleData[closeIndex].GetDouble(), High = candleData[highIndex].GetDouble(), Low = candleData[lowIndex].GetDouble(), Value = candleData[valueIndex].GetDouble(), Volume = candleData[volumeIndex].GetDouble(), DateTime = DateTime.Parse(candleData[dateTimeIndex].GetString()), }); } return(candles); }
public async void Unsubscribe(string classCode, string securityCode, CandleInterval interval) { var message = new Message <string>(classCode + "|" + securityCode + "|" + (int)interval, "unsubscribe_from_candles"); await QuikService.Send <Message <string> >(message); }
/// <summary> /// Возвращает заданное количество свечек указанного инструмента и интервала с конца. /// </summary> /// <param name="classCode">Класс инструмента.</param> /// <param name="securityCode">Код инструмента.</param> /// <param name="interval">Интервал свечей.</param> /// <param name="count">Количество возвращаемых свечей с конца.</param> /// <returns>Список свечей.</returns> public async Task<List<Candle>> GetLastCandles(string classCode, string securityCode, CandleInterval interval, int count) { var message = new Message<string>(classCode + "|" + securityCode + "|" + (int)interval + "|" + count, "get_candles_from_data_source"); Message<List<Candle>> response = await QuikService.Send<Message<List<Candle>>>(message); return response.Data; }
public static CandleUnsubscribeRequest UnsubscribeCandle(string figi, CandleInterval interval) { return(new CandleUnsubscribeRequest(figi, interval)); }
public CandleUnsubscribeRequest(string figi, CandleInterval interval, string requestId = null) : base(requestId) { Figi = figi; Interval = interval; }
public void init(ApiHelp kh, CandleInterval ci, CandleManager cm) { this._api = kh; this._ci = ci; this._data = new Indikators(cm, ci); this._cm = cm; }
private void LoadChart(string symbol, CandleInterval interval) { CurrentLoadedSymbol = symbol; CurrentInterval = interval; //client.SetApiCredentials("118180a6a91e29425c90c2e2afe349aa71", "e36a6307025c4b4fb1b20a4a00c4c9ef"); client.SetApiCredentials(Key, Secret); //get min trade size var markets = client.GetSymbols(); if (markets.Data != null) { var market = markets.Data.FirstOrDefault(l => l.Symbol == symbol); CurrentMinTradeSize = market.MinTradeSize; } //get high low data var summary = client.GetSymbolSummary(symbol); if (summary.Data != null) { CurrentPriceHigh = summary.Data.High; CurrentPriceLow = summary.Data.Low; } //get balance for currency var balance = client.GetBalance(symbol.Substring(0, 3)); if (balance.Data != null) { AccountBalance = balance.Data.Available.ToString() + " " + balance.Data.Currency; } //get order history var orderhistory = client.GetOrderBook(symbol); if (orderhistory.Data != null) { OrderBook = orderhistory.Data; } //get closed orders var d = client.GetClosedOrders(symbol); if (d.Data != null) { ClosedOrders = new ObservableCollection <BittrexOrderV3>(d.Data); } //get open orders var o = client.GetOpenOrders(symbol); if (o.Data != null) { OpenOrders = new ObservableCollection <BittrexOrderV3>(o.Data); } //var balance = client.GetBalance(CurrentLoadedSymbol); //if (balance.Data != null) //{ // AccountBalance = balance.Data.Total.ToString(); //} //else //{ // AccountBalance = "0.00"; //} string intervalstring = ""; if (interval == CandleInterval.Day1) { intervalstring = "DAY_1"; } else if (interval == CandleInterval.Hour1) { intervalstring = "HOUR_1"; } else if (interval == CandleInterval.Minute1) { intervalstring = "MINUTE_1"; } else if (interval == CandleInterval.Minutes5) { intervalstring = "MINUTE_5"; } var coincandledatajson = CallRestMethod("https://api.bittrex.com/v3/markets/" + symbol + "/candles/" + intervalstring + "/recent"); var coincandledata = JsonConvert.DeserializeObject <CandleData[]>(coincandledatajson); coinsCb.SelectedItem = symbol; //defualt foreach (CandleData candle in coincandledata) { candle.Time = candle.StartsAt.DateTime; } if (plotmodel != null) { plotmodel.Series.Clear(); } OxyPlot.PlotModel model = new OxyPlot.PlotModel(); //x model.Axes.Add(new DateTimeAxis { //StringFormat = "hh:mm", Title = "Time", AxislineColor = OxyColors.White, TitleColor = OxyColors.White, TicklineColor = OxyColors.White, TextColor = OxyColors.White, MinorIntervalType = DateTimeIntervalType.Auto, Position = AxisPosition.Bottom, }); XAxis = model.Axes[0]; //y model.Axes.Add(new LinearAxis() { Title = "Market Price", Position = AxisPosition.Left, AxislineColor = OxyColors.White, TitleColor = OxyColors.White, TicklineColor = OxyColors.White, TextColor = OxyColors.White, }); YAxis = model.Axes[1]; //create plot model and add the line series CandleStickSeries data = new CandleStickSeries() { Title = symbol }; data.DataFieldClose = "Close"; data.DataFieldHigh = "High"; data.DataFieldLow = "Low"; data.DataFieldOpen = "Open"; data.DataFieldX = "Time"; data.Color = OxyColors.DarkGray; data.IncreasingColor = OxyColors.Green; data.DecreasingColor = OxyColors.Red; data.ItemsSource = coincandledata; data.TrackerFormatString = "Date: {2}\nOpen: {5:0.00000}\nHigh: {3:0.00000}\nLow: {4:0.00000}\nClose: {6:0.00000}"; plotmodel = model; model.PlotAreaBorderColor = OxyColors.White; model.LegendTextColor = OxyColors.YellowGreen; model.Series.Add(data); model.Background = OxyColors.Black; model.MouseUp += Model_MouseUp;; model.MouseDown += Model_MouseDown;; plotview.Model = model; if (LimitLineSeries != null) { DrawLimitLine(OrderSide.Buy, LimitLineSeries); } }
public async Task <List <Candle> > GetCandlesHistory(string figi, DateTime from, DateTime to, CandleInterval candleInterval) { int delay = TimeDelay / RetriesCount; int ost = TimeDelay % RetriesCount; for (int i = 0; i < RetriesCount; i++) { try { switch (_mode) { case Mode.Sandbox: var listS = await _sandboxContext.MarketCandlesAsync(figi, from, to, candleInterval); var candles = listS.Candles.Select(x => new Candle { close = (double)x.Close, figi = x.Figi, high = (double)x.High, interval = (CandleIntervalEnum)x.Interval, low = (double)x.Low, open = (double)x.Open, time = x.Time, volume = (double)x.Volume }).ToList(); return(candles); case Mode.Bourse: var listB = await _bourseContext.MarketCandlesAsync(figi, from, to, candleInterval); var candlesB = listB.Candles.Select(x => new Candle { close = (double)x.Close, figi = x.Figi, high = (double)x.High, interval = (CandleIntervalEnum)x.Interval, low = (double)x.Low, open = (double)x.Open, time = x.Time, volume = (double)x.Volume }).ToList(); return(candlesB); default: throw new NotImplementedException(); } } catch { if (i == RetriesCount - 1) { delay += ost; } System.Threading.Thread.Sleep(delay); } } throw new Exception("Error send"); }
/// <summary> /// Функция возвращает список свечек указанного инструмента заданного интервала. /// </summary> /// <param name="classCode">Класс инструмента.</param> /// <param name="securityCode">Код инструмента.</param> /// <param name="interval">Интервал свечей.</param> /// <returns>Список свечей.</returns> public async Task<List<Candle>> GetAllCandles(string classCode, string securityCode, CandleInterval interval) { //Параметр count == 0 говорт о том, что возвращаются все доступные свечи return await GetLastCandles(classCode, securityCode, interval, 0); }
public async Task<bool> IsSubscribed(string classCode, string securityCode, CandleInterval interval) { var message = new Message<string>(classCode + "|" + securityCode + "|" + (int)interval, "is_subscribed"); Message<bool> response = await QuikService.Send<Message<bool>>(message); return response.Data; }
private CandleRequest(bool subscribe, string figi, CandleInterval interval) : base(subscribe, "candle") { Figi = figi; Interval = interval.Value; }
/// <summary> /// take candles by instrument /// взять свечи по инструменту /// </summary> /// <param name="security"> short security name/короткое название бумаги</param> /// <param name="timeSpan">timeframe/таймФрейм</param> /// <returns>failure will return null/в случае неудачи вернётся null</returns> public List <Candle> GetQuikLuaCandleHistory(Security security, TimeSpan timeSpan) { try { lock (_getCandlesLocker) { if (timeSpan.TotalMinutes > 1440 || timeSpan.TotalMinutes < 1) { return(null); } CandleInterval tf = CandleInterval.M5; if (Convert.ToInt32(timeSpan.TotalMinutes) == 1) { tf = CandleInterval.M1; } else if (Convert.ToInt32(timeSpan.TotalMinutes) == 2) { tf = CandleInterval.M2; } else if (Convert.ToInt32(timeSpan.TotalMinutes) == 5) { tf = CandleInterval.M5; } else if (Convert.ToInt32(timeSpan.TotalMinutes) == 10) { tf = CandleInterval.M10; } else if (Convert.ToInt32(timeSpan.TotalMinutes) == 15) { tf = CandleInterval.M15; } else if (Convert.ToInt32(timeSpan.TotalMinutes) == 20) { tf = CandleInterval.M20; } else if (Convert.ToInt32(timeSpan.TotalMinutes) == 30) { tf = CandleInterval.M30; } else if (Convert.ToInt32(timeSpan.TotalMinutes) == 60) { tf = CandleInterval.H1; } else if (Convert.ToInt32(timeSpan.TotalMinutes) == 120) { tf = CandleInterval.H2; } else if (Convert.ToInt32(timeSpan.TotalMinutes) == 240) { tf = CandleInterval.H4; } else if (Convert.ToInt32(timeSpan.TotalMinutes) == 1440) { tf = CandleInterval.D1; } #region MyRegion _candles = null; var needSec = security; if (needSec != null) { _candles = new List <Candle>(); string classCode = needSec.NameClass; var allCandlesForSec = QuikLua.Candles.GetAllCandles(classCode, needSec.Name.Split('_')[0], tf).Result; for (int i = 0; i < allCandlesForSec.Count; i++) { if (allCandlesForSec[i] != null) { Candle newCandle = new Candle(); newCandle.Close = allCandlesForSec[i].Close; newCandle.High = allCandlesForSec[i].High; newCandle.Low = allCandlesForSec[i].Low; newCandle.Open = allCandlesForSec[i].Open; newCandle.Volume = allCandlesForSec[i].Volume; if (i == allCandlesForSec.Count - 1) { newCandle.State = CandleState.None; } else { newCandle.State = CandleState.Finished; } newCandle.TimeStart = new DateTime(allCandlesForSec[i].Datetime.year, allCandlesForSec[i].Datetime.month, allCandlesForSec[i].Datetime.day, allCandlesForSec[i].Datetime.hour, allCandlesForSec[i].Datetime.min, allCandlesForSec[i].Datetime.sec); _candles.Add(newCandle); } } } #endregion return(_candles); } } catch (Exception error) { SendLogMessage(error.ToString(), LogMessageType.Error); return(null); } }
internal static CandleRequest Unsubscribe(string figi, CandleInterval interval) { return(new CandleRequest(false, figi, interval)); }
public async Task <IActionResult> GetCandlesHistory(string figi, string from, string to, CandleInterval candleInterval = CandleInterval.Minute) { var type = "O"; var result = await _tinkoffService.GetCandlesHistory(figi, DateTime.ParseExact(from, type, CultureInfo.InvariantCulture), DateTime.ParseExact(to, type, CultureInfo.InvariantCulture), candleInterval); return(Ok(result)); }
public async void Unsubscribe(string classCode, string securityCode, CandleInterval interval) { var message = new Message<string>(classCode + "|" + securityCode + "|" + (int)interval, "unsubscribe_from_candles"); await QuikService.Send<Message<string>>(message); }
// В ассинхронных фукнциях нельзя возвращать void, вместо этого нужно возвращать Task. Иначе нельзя будет ожидать фукнцию и ловить исключения public async Task Subscribe(string classCode, string securityCode, CandleInterval interval) { var message = new Message <string>(classCode + "|" + securityCode + "|" + (int)interval, "subscribe_to_candles"); await QuikService.Send <Message <string> >(message).ConfigureAwait(false); }