private static UserHeader DeserializeUser(KeyValuePair<string, string>[] propertyBag)
 {
     return new UserHeader
     {
         Id = new Guid(propertyBag.First(item => item.Key == IdProperty).Value),
         Email = propertyBag.First(item => item.Key == EMailProperty).Value,
         Role = ParseRole(propertyBag.First(item => item.Key == RoleProperty).Value),
         FirstName = propertyBag.First(item => item.Key == FirstNameProperty).Value,
         LastName = propertyBag.First(item => item.Key == LastNameProperty).Value,
     };
 }
        public void CopyToTest()
        {
            PromiseCollection <int> collection = GetCollection();

            KeyValuePair <string, IPromise <int> >[] array = new KeyValuePair <string, IPromise <int> > [1];
            collection.CopyTo(array, 0);
            Assert.AreEqual(collection.First(), array.First());
        }
Beispiel #3
0
        public override void OnNavigatedTo(KeyValuePair<string, string>[] argument = null)
        {
            Station station = App.AvailableStations.First(x => x.Title == argument.First(y => y.Key == "Station").Value);

            LoadSongHistory(station);

            base.OnNavigatedTo(argument);
        }
Beispiel #4
0
        public void Should_not_loose_headers()
        {
            var headers = new KeyValuePair <string, string> [0];

            _bus.SubscribeContextHandler <A>(ctx =>
            {
                headers = ctx.Headers.ToArray();
                _receivedA.Set();
            });

            _bus.ScheduleMessage(1.Seconds().FromUtcNow(), new A {
                Name = "Joe"
            },
                                 ctx =>
            {
                ctx.SetHeader("ATest", "AValue");
            });

            Assert.IsTrue(_receivedA.WaitOne(Utils.Timeout), "Message A not handled");
            Assert.IsNotEmpty(headers, "No Headers were sent");
            Assert.AreEqual("AValue", headers.First(h => h.Key == "ATest").Value);
        }
Beispiel #5
0
        /// <summary>
        /// Update the logger - you can call this periodically if you don't want to call Start to run the logger in a background thread.
        /// </summary>
        public async Task UpdateAsync()
        {
            ExchangeTrade[]  newTrades;
            HashSet <string> tmpTradeIds;

            try
            {
                if (MarketSymbol == "*")
                {
                    // get all symbols
                    Tickers = (await API.GetTickersAsync()).ToArray();
                    tickerWriter.Write(Tickers.Count);
                    foreach (KeyValuePair <string, ExchangeTicker> ticker in Tickers)
                    {
                        tickerWriter.Write(ticker.Key);
                        ticker.Value.ToBinary(tickerWriter);
                    }
                }
                else
                {
                    // make API calls first, if they fail we will try again later
                    Tickers = new KeyValuePair <string, ExchangeTicker>[1] {
                        new KeyValuePair <string, ExchangeTicker>(MarketSymbol, await API.GetTickerAsync(MarketSymbol))
                    };
                    OrderBook = await API.GetOrderBookAsync(MarketSymbol);

                    Trades = (await API.GetRecentTradesAsync(MarketSymbol)).OrderBy(t => t.Timestamp).ToArray();

                    // all API calls succeeded, we can write to files

                    // write system date / time
                    sysTimeWriter.Write(CryptoUtility.UtcNow.Ticks);

                    // write ticker
                    Tickers.First().Value.ToBinary(tickerWriter);

                    // write order book
                    OrderBook.ToBinary(bookWriter);

                    // new trades only
                    newTrades = Trades.Where(t => !tradeIds.Contains(t.Id)).ToArray();

                    // write new trades
                    tradeWriter.Write(newTrades.Length);
                    foreach (ExchangeTrade trade in newTrades)
                    {
                        trade.ToBinary(tradeWriter);
                    }

                    // track trade ids for the latest set of trades
                    foreach (ExchangeTrade trade in Trades)
                    {
                        tradeIds2.Add(trade.Id);
                    }
                    tmpTradeIds = tradeIds;
                    tradeIds    = tradeIds2;
                    tradeIds2   = tmpTradeIds;
                    tradeIds2.Clear();
                }

                DataAvailable?.Invoke(this);
            }
            catch (Exception ex)
            {
                Error?.Invoke(this, ex);
            }
        }
        public void loadObjects(KeyValuePair<string, string>[] objects)
        {
            cachedObjects = new JsDictionary<string, LevelObject>();

            foreach (LevelObjectInfo t in SonicLevel.Objects)
            {
                var o = t.Key;
                if (cachedObjects.ContainsKey(o))
                {
                    t.SetObjectData(cachedObjects[o]);
                    continue;
                }
                var d = objects.First(p => p.Key == o);
                if (d.Falsey())
                {
                    t.SetObjectData(new LevelObject(o));
                    continue;
                }
                LevelObjectData dat;
                if (d.Value.Length == 0) dat = new LevelObjectData();
                else dat = (LevelObjectData)Json.Parse(d.Value);

                var dr = ObjectManager.ExtendObject(dat);
                cachedObjects[o] = dr;
                t.SetObjectData(dr);
            }

            /* 
        OurSonic.SonicLevels.getObjects(objectKeys, function (objects) {
            window.CachedObjects = [];
            for (l = 0; l < sonicManager.SonicLevel.Objects.length; l++) {
                o = sonicManager.SonicLevel.Objects[l].key;
                if (window.CachedObjects[o]) {
                    sonicManager.SonicLevel.Objects[l].setObjectData(window.CachedObjects[o]);
                    continue;
                }
                var d = JSLINQ(objects).First(function (p) { return p.key == o; });
                if (!d) {
                    sonicManager.SonicLevel.Objects[l].setObjectData(new LevelObject(o));
                    continue;
                }

                var dr = _H.extend(new LevelObject(""), jQuery.parseJSON(d.value));
                dr = sonicManager.objectManager.extendObject(dr);

                for (var n = 0; n < dr.assets.length; n++) {
                    for (var s = 0; s < dr.assets[n].frames.length; s++) {
                        dr.assets[n].frames[s].hurtSonicMap.length = dr.assets[n].frames[s].width;
                        dr.assets[n].frames[s].collisionMap.length = dr.assets[n].frames[s].width;
                        for (var t = 0; t < dr.assets[n].frames[s].hurtSonicMap.length; t++) {
                            dr.assets[n].frames[s].hurtSonicMap[t].length = dr.assets[n].frames[s].height;
                            dr.assets[n].frames[s].collisionMap[t].length = dr.assets[n].frames[s].height;

                        }
                    }
                }

                window.CachedObjects[o] = dr;
                sonicManager.SonicLevel.Objects[l].setObjectData(dr);

            }

        });

*/
        }
Beispiel #7
0
        public void TryGetValue()
        {
            string actual;
            var    dict = new Dictionary <int, string>();

            for (int i = 0; i < 10; i++)
            {
                dict[i] = i.ToString();
            }
            dict.TryGetValue(2, out actual);
            var sw = Stopwatch.StartNew();
            var n  = 1000000;

            for (int i = 0; i < n; i++)
            {
                dict.TryGetValue(i % 10, out actual);
            }

            sw.Stop();
            Console.WriteLine($"// {DateTime.Today.ToShortDateString()}| dict.TryGetValue(i % 10, out actual)       {n:N0} times {sw.ElapsedMilliseconds} ms");

            var cdict = new ConcurrentDictionary <int, string>();

            for (int i = 0; i < 10; i++)
            {
                cdict[i] = i.ToString();
            }

            cdict.TryGetValue(2, out actual);
            sw.Restart();
            for (int i = 0; i < n; i++)
            {
                cdict.TryGetValue(i % 10, out actual);
            }

            sw.Stop();
            Console.WriteLine($"// {DateTime.Today.ToShortDateString()}| cdict.TryGetValue(i % 10, out actual);     {n:N0} times {sw.ElapsedMilliseconds} ms");

            var slist = new SortedList <int, string>();

            for (int i = 0; i < 10; i++)
            {
                slist[i] = i.ToString();
            }

            slist.TryGetValue(2, out actual);
            sw.Restart();
            for (int i = 0; i < n; i++)
            {
                slist.TryGetValue(i % 10, out actual);
            }

            sw.Stop();
            Console.WriteLine($"// {DateTime.Today.ToShortDateString()}| slist.TryGetValue(i % 10, out actual);     {n:N0} times {sw.ElapsedMilliseconds} ms");

            var array = new KeyValuePair <int, string> [10];

            for (int i = 0; i < 10; i++)
            {
                array[i] = new KeyValuePair <int, string>(i, i.ToString());
            }

            var kvp = Array.Find(array, x => x.Key == 2);

            sw.Restart();
            for (int i = 0; i < n; i++)
            {
                kvp = Array.Find(array, x => x.Key == i % 10);
            }

            sw.Stop();
            Console.WriteLine($"// {DateTime.Today.ToShortDateString()}| Array.Find(array, x => x.Key == i % 10)    {n:N0} times {sw.ElapsedMilliseconds} ms");

            sw.Restart();
            var kvpComparer = new KvpComparer();

            for (int i = 0; i < n; i++)
            {
                var j = Array.BinarySearch(array, array[i % 10], kvpComparer);
            }

            sw.Stop();
            Console.WriteLine($"// {DateTime.Today.ToShortDateString()}| Array.BinarySearch(array, array[i % 10])   {n:N0} times {sw.ElapsedMilliseconds} ms");

            sw.Restart();

            for (int i = 0; i < n; i++)
            {
                var j = array.BinarySearchBy(x => x.Key, i % 10);
            }

            sw.Stop();
            Console.WriteLine($"// {DateTime.Today.ToShortDateString()}| array.BinarySearchBy(x => x.Key, i % 10    {n:N0} times {sw.ElapsedMilliseconds} ms");

            sw.Restart();

            for (int i = 0; i < n; i++)
            {
                kvp = array.First(x => x.Key == i % 10);
            }

            sw.Stop();
            Console.WriteLine($"// {DateTime.Today.ToShortDateString()}| array.First(x => x.Key == i % 10)          {n:N0} times {sw.ElapsedMilliseconds} ms");
        }
        public void Should_not_loose_headers()
        {
            var headers = new KeyValuePair<string, string>[0];
            _bus.SubscribeContextHandler<A>(ctx =>
            {
                headers = ctx.Headers.ToArray();
                _receivedA.Set();
            });

            _bus.ScheduleMessage(1.Seconds().FromUtcNow(), new A { Name = "Joe" },
                ctx =>
                {
                    ctx.SetHeader("ATest", "AValue");
                });

            Assert.IsTrue(_receivedA.WaitOne(Utils.Timeout), "Message A not handled");
            Assert.IsNotEmpty(headers, "No Headers were sent");
            Assert.AreEqual("AValue", headers.First(h => h.Key == "ATest").Value);
        }