Пример #1
0
        private void popList1_Selected(object sender, EventArgs e)
        {
            switch (popList1.Selections[0].Text)
            {
            case "DataBind":
                DataBind();
                break;

            case "AddSet":
                this.candleStickChart1.Data.AddSeries(GetNewSerie(this.candleStickChart1.Data));
                break;

            case "RemoveSet":
                if (this.candleStickChart1.Data.SeriesCount > 0)
                {
                    this.candleStickChart1.Data.RemoveSeries(0);
                }
                break;

            case "ClearSet":
                this.candleStickChart1.Data.ClearValues();
                break;

            case "SetData":
                List <string> xLabels = new List <string>();
                xLabels.AddRange(new string[] { "1", "2", "3", "4" });
                CandleStickData data = new CandleStickData(xLabels);
                data.AddSeries(GetNewSerie(data));
                this.candleStickChart1.Data = data;
                break;
            }
        }
Пример #2
0
        protected virtual void OnKlineItemRecv(Ticker ticker, string[] item)
        {
            long     dt   = FastValueConverter.ConvertPositiveLong(item[0]);
            DateTime time = FromUnixTime(dt);
            CandleStickIntervalInfo info = null;

            for (int ci = 0; ci < AllowedCandleStickIntervals.Count; ci++)
            {
                CandleStickIntervalInfo i = AllowedCandleStickIntervals[ci];
                if (i.Command == item[3])
                {
                    info = i;
                    break;
                }
            }
            if (ticker.CandleStickPeriodMin != info.Interval.TotalMinutes)
            {
                return;
            }
            //Debug.WriteLine(item[6] + " " + item[7] + " " + item[8] + " " + item[9]);
            lock (ticker.CandleStickData) {
                CandleStickData data = new CandleStickData();
                data.Time        = time;
                data.Open        = FastValueConverter.Convert(item[6]);
                data.Close       = FastValueConverter.Convert(item[7]);
                data.High        = FastValueConverter.Convert(item[8]);
                data.Low         = FastValueConverter.Convert(item[9]);
                data.Volume      = FastValueConverter.Convert(item[10]);
                data.QuoteVolume = FastValueConverter.Convert(item[13]);
                ticker.UpdateCandleStickData(data);
            }
        }
        public void TestItemAdded()
        {
            Ticker ticker = new Binance.BinanceTicker(Binance.BinanceExchange.Default);

            ticker.CandleStickData = GetCandleSticks(100);

            MacdIndicator macd = new MacdIndicator()
            {
                Ticker = ticker, Source = IndicatorSource.Close, Length = 9
            };
            StochasticIndicator stoch = new StochasticIndicator()
            {
                Ticker = ticker, Source = IndicatorSource.Close, Length = 9
            };

            macd.Calculate();
            stoch.Calculate();

            for (int i = 0; i < 10; i++)
            {
                CandleStickData date = GetCandleStick(DateTime.Now.AddMinutes(1));
                macd.OnAddValue();
                stoch.OnAddValue();
            }

            Assert.AreEqual(110, macd.Result.Count);
            Assert.AreEqual(110, macd.FastEmaIndicator.Result.Count);
            Assert.AreEqual(110, macd.SlowEmaIndicator.Result.Count);
            Assert.AreEqual(110, macd.SignalMaIndicator.Result.Count);

            Assert.AreEqual(110, stoch.MinIndicator.Result.Count);
            Assert.AreEqual(110, stoch.MaxIndicator.Result.Count);
            Assert.AreEqual(110, stoch.Result.Count);
        }
        protected CandleStickData CreateStartCandleStick(CandleStickData data)
        {
            CandleStickData res = new CryptoMarketClient.CandleStickData();

            res.Assign(data);
            res.Open = res.Close = res.High = res.Low = data.Open;
            return(res);
        }
Пример #5
0
        protected double CalculateCore(int forIndex)
        {
            CandleStickData curr = Ticker.CandleStickData[forIndex];
            CandleStickData prev = Ticker.CandleStickData[forIndex - 1];
            double          tr   = Math.Max(curr.High - curr.Low, Math.Max(Math.Abs(curr.High - prev.Close), Math.Abs(curr.Low - prev.Close)));

            return(tr);
        }
Пример #6
0
        public override BindingList <CandleStickData> GetCandleStickData(Ticker ticker, int candleStickPeriodMin, DateTime startUtc, long periodInSeconds)
        {
            long startSec = (long)(startUtc.Subtract(epoch)).TotalSeconds;
            long end      = startSec + periodInSeconds;
            CandleStickIntervalInfo info = AllowedCandleStickIntervals.FirstOrDefault(i => i.Interval.TotalMinutes == candleStickPeriodMin);

            string address = string.Format("https://api.binance.com/api/v1/klines?symbol={0}&interval={1}&startTime={2}&endTime={3}&limit=10000",
                                           Uri.EscapeDataString(ticker.CurrencyPair), info.Command, startSec * 1000, end * 1000);

            byte[] bytes = null;
            try {
                bytes = GetDownloadBytes(address);
            }
            catch (Exception) {
                return(null);
            }
            if (bytes == null || bytes.Length == 0)
            {
                return(null);
            }

            DateTime startTime = epoch;

            BindingList <CandleStickData> list = new BindingList <CandleStickData>();
            int             startIndex         = 0;
            List <string[]> res = JSonHelper.Default.DeserializeArrayOfArrays(bytes, ref startIndex, 12);

            if (res == null)
            {
                return(list);
            }
            foreach (string[] item in res)
            {
                CandleStickData data = new CandleStickData();
                data.Time          = startTime.AddMilliseconds(FastValueConverter.ConvertPositiveLong(item[0])).ToLocalTime();
                data.Open          = FastValueConverter.Convert(item[1]);
                data.High          = FastValueConverter.Convert(item[2]);
                data.Low           = FastValueConverter.Convert(item[3]);
                data.Close         = FastValueConverter.Convert(item[4]);
                data.Volume        = FastValueConverter.Convert(item[5]);
                data.QuoteVolume   = FastValueConverter.Convert(item[7]);
                data.BuyVolume     = FastValueConverter.Convert(item[9]);
                data.SellVolume    = data.Volume - data.BuyVolume;
                data.BuySellVolume = data.BuyVolume - data.SellVolume;
                list.Add(data);
            }

            //List<TradeInfoItem> trades = GetTradeVolumesForCandleStick(ticker, startSec * 1000, end * 1000);
            //CandleStickChartHelper.InitializeVolumes(list, trades, ticker.CandleStickPeriodMin);
            return(list);
        }
Пример #7
0
        public override BindingList <CandleStickData> GetCandleStickData(Ticker ticker, int candleStickPeriodMin, DateTime start, long periodInSeconds)
        {
            long startSec = (long)(start.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
            long end      = startSec + periodInSeconds;

            string address = string.Format("https://bittrex.com/Api/v2.0/pub/market/GetTicks?marketName={0}&tickInterval={1}&_={2}",
                                           Uri.EscapeDataString(ticker.CurrencyPair), GetInvervalCommand(candleStickPeriodMin), GetNonce());

            byte[] bytes = null;
            try {
                bytes = GetDownloadBytes(address);
            }
            catch (Exception) {
                return(null);
            }
            if (bytes == null || bytes.Length == 0)
            {
                return(null);
            }

            BindingList <CandleStickData> list = new BindingList <CandleStickData>();

            int startIndex = 1;

            if (!JSonHelper.Default.SkipSymbol(bytes, ':', 3, ref startIndex))
            {
                return(list);
            }

            List <string[]> res = JSonHelper.Default.DeserializeArrayOfObjects(bytes, ref startIndex, new string[] { "O", "H", "L", "C", "V", "T", "BV" });

            if (res == null)
            {
                return(list);
            }
            foreach (string[] item in res)
            {
                CandleStickData data = new CandleStickData();
                data.Time            = Convert.ToDateTime(item[5]);
                data.High            = FastValueConverter.Convert(item[1]);
                data.Low             = FastValueConverter.Convert(item[2]);
                data.Open            = FastValueConverter.Convert(item[0]);
                data.Close           = FastValueConverter.Convert(item[3]);
                data.Volume          = FastValueConverter.Convert(item[6]);
                data.QuoteVolume     = FastValueConverter.Convert(item[4]);
                data.WeightedAverage = 0;
                list.Add(data);
            }
            return(list);
        }
        public DateTime GetEndTime()
        {
            DateTime end = DateTime.MinValue;

            if (SimulationData != null)
            {
                return(SimulationData[SimulationData.Count - 1].Time);
            }
            if (CaptureDataHistory != null)
            {
                end = MaxTime(end, CaptureDataHistory.Items.Last().Time);
            }
            if (CandleStickData != null)
            {
                end = MaxTime(end, CandleStickData.Last().Time);
            }
            return(end);
        }
        public DateTime GetStartTime()
        {
            DateTime start = DateTime.MaxValue;

            if (SimulationData != null)
            {
                return(SimulationData[0].Time);
            }
            if (CaptureDataHistory != null)
            {
                start = MinTime(start, CaptureDataHistory.Items.First().Time);
            }
            if (CandleStickData != null)
            {
                start = MinTime(start, CandleStickData.First().Time);
            }
            return(start);
        }
Пример #10
0
        private CandleStickSeries GetNewSerie(CandleStickData data)
        {
            Random countRandom = new Random();
            ChartYAxisValueCollection <CandleStickYAxisValue> yVals = new ChartYAxisValueCollection <CandleStickYAxisValue>();
            int count = data.XAxisCount;

            for (int i = 0; i < count; i++)
            {
                yVals.Add(new CandleStickYAxisValue(countRandom.Next(0, count), countRandom.Next(0, count), countRandom.Next(0, count), countRandom.Next(0, count)));
            }
            CandleStickSeries set1 = new CandleStickSeries(yVals, "DataSet 1");

            set1.AddColor(DemoGlobal.GetRandomColor());
            set1.AddColor(DemoGlobal.GetRandomColor());
            set1.AddColor(DemoGlobal.GetRandomColor());

            return(set1);
        }
Пример #11
0
        public override BindingList <CandleStickData> GetCandleStickData(TickerBase ticker, int candleStickPeriodMin, DateTime start, long periodInSeconds)
        {
            string address           = string.Format("https://yobit.net/ajax/system_chart.php");
            NameValueCollection coll = new NameValueCollection();

            coll.Add("method", "chart");
            coll.Add("nonce", DateTime.Now.Ticks.ToString());
            coll.Add("pair_id", "40001");
            coll.Add("mode", "12");

            WebClient client = GetWebClient();

            try {
                byte[] data = client.UploadValues(address, coll);
                string text = System.Text.Encoding.ASCII.GetString(data);
                if (string.IsNullOrEmpty(text))
                {
                    return(null);
                }
                JObject res   = (JObject)JsonConvert.DeserializeObject(text);
                JArray  items = res.Value <JArray>("data");
                BindingList <CandleStickData> list = new BindingList <CandleStickData>();
                foreach (JArray item in items)
                {
                    CandleStickData c       = new CandleStickData();
                    long            seconds = item[0].Value <long>();
                    c.Time        = new DateTime(1970, 1, 1).AddMilliseconds(seconds);
                    c.Volume      = item[1].Value <double>();
                    c.QuoteVolume = item[2].Value <double>();
                    c.Open        = item[3].Value <double>();
                    c.High        = item[4].Value <double>();
                    c.Low         = item[5].Value <double>();
                    c.Close       = item[6].Value <double>();
                    list.Add(c);
                }
                return(list);
            }
            catch (Exception e) {
                Debug.WriteLine("get candlestcik history exception: " + e.ToString());
                return(null);
            }
        }
        public DateTime GetStartTime()
        {
            DateTime start = DateTime.MinValue;

            if (SimulationData != null)
            {
                return(SimulationData[0].Time);
            }
            if (CaptureDataHistory != null)
            {
                start = MaxTime(start, CaptureDataHistory.Items.First().Time);
            }
            if (CandleStickData != null)
            {
                start = MaxTime(start, CandleStickData.First().Time);
            }
            if (Trades != null && Trades.Count > 0)
            {
                start = MaxTime(start, Trades[0].Time);
            }
            return(start);
        }
Пример #13
0
        protected virtual void OnKlineItemRecv(Ticker ticker, string[] item)
        {
            long     dt   = FastValueConverter.ConvertPositiveLong(item[0]);
            DateTime time = FromUnixTime(dt);
            CandleStickIntervalInfo info = AllowedCandleStickIntervals.FirstOrDefault(i => i.Command == item[3]);

            if (ticker.CandleStickPeriodMin != info.Interval.TotalMinutes)
            {
                return;
            }
            Debug.WriteLine(item[6] + " " + item[7] + " " + item[8] + " " + item[9]);
            lock (ticker.CandleStickData) {
                CandleStickData data = ticker.GetOrCreateCandleStickData(time);
                data.Open        = FastValueConverter.Convert(item[6]);
                data.Close       = FastValueConverter.Convert(item[7]);
                data.High        = FastValueConverter.Convert(item[8]);
                data.Low         = FastValueConverter.Convert(item[9]);
                data.Volume      = FastValueConverter.Convert(item[10]);
                data.QuoteVolume = FastValueConverter.Convert(item[13]);
                ticker.RaiseCandleStickChanged();
            }
        }