コード例 #1
0
ファイル: AccountCache.cs プロジェクト: hlslml77/fist
        /// <summary>
        /// 判断账号密码是否存在正确
        /// </summary>
        /// <param name="acc"></param>
        /// <param name="pwd"></param>
        /// <returns></returns>
        public bool Match(string acc, string pwd)
        {
            //if (!accModelDict.ContainsKey(acc))
            //    return false;
            //return accModelDict[acc].Password == pwd;

            //如果内存里面有 直接判断
            if (accModelDict.ContainsKey(acc))
            {
                return(accModelDict[acc].Password == pwd);
            }

            AccountModel model = new AccountModel();

            //如果没有 那就真的没有
            if (!model.Exists(acc))
            {
                return(false);
            }
            //如果数据库里面存在
            model.GetModel(acc);
            //添加到内存里
            accModelDict.TryAdd(model.Account, model);
            //再进行判断
            return(model.Password == pwd);
        }
コード例 #2
0
        public IDictionary <long, IList <WorkSchedule> > GetAll(short pastMonths, short newMonths)
        {
            SynchronizedDictionary <long, IList <WorkSchedule> > result = new SynchronizedDictionary <long, IList <WorkSchedule> >();
            List <Task> tasks    = new List <Task>();
            DateTime    firstDay = DateTime.Now.AddDays(1 - DateTime.Now.Day).Date;
            DateTime    lastDay  = firstDay.AddMonths(1).AddMilliseconds(-1);

            foreach (ProjectInfoS item in ProjectInfoS.FetchList(Database.Default,
                                                                 p => p.OriginateTime <= lastDay && (p.ClosedDate == null || p.ClosedDate >= firstDay)))
            {
                //项目经理
                long projectManager = item.ProjectManager;
                if (!result.ContainsKey(projectManager))
                {
                    result.Add(projectManager, null);
                    tasks.Add(Task.Run(async() =>
                    {
                        result[projectManager] = await ClusterClient.Default.GetGrain <IWorkScheduleGrain>(projectManager).FetchWorkSchedules(pastMonths, newMonths);
                    }));
                }
                //开发经理
                long developManager = item.DevelopManager;
                if (!result.ContainsKey(developManager))
                {
                    result.Add(developManager, null);
                    tasks.Add(Task.Run(async() =>
                    {
                        result[developManager] = await ClusterClient.Default.GetGrain <IWorkScheduleGrain>(developManager).FetchWorkSchedules(pastMonths, newMonths);
                    }));
                }
            }

            Task.WaitAll(tasks.ToArray());
            return(result);
        }
コード例 #3
0
        public void DictionaryCopyConstructorProperlyCopiesEntriesAndSetsGottenTracking()
        {
            var other = new Dictionary <string, string>();

            other.Add("key1", "otherValue1");
            other.Add("key2", "otherValue2");

            // trackAccessed = false, trackGotten = true
            var sd = new SynchronizedDictionary <string, string>(other, false, true);

            Assert.IsTrue(sd.ContainsKey("key1"));
            Assert.IsTrue(sd.ContainsKey("key2"));

            Assert.AreEqual(sd["key1"], "otherValue1");
            Assert.AreEqual(sd["key2"], "otherValue2");

            // Accessed Tracking is disabled
            Assert.IsFalse(sd.TrackAccessed);
            Assert.IsNull(sd.Accessed);

            // Accessed Tracking is enabled
            Assert.IsTrue(sd.TrackGotten);
            Assert.IsNotNull(sd.Gotten);
            Assert.AreEqual(sd.Gotten.Count, 2);
        }
コード例 #4
0
        /// <summary>
        /// Has this particular URL been cached?
        /// </summary>
        /// <param name="URL">The URL.</param>
        /// <returns>Returns true if the URL has been cached.</returns>
        public virtual bool HasCached(string URL, string POST = null, int maxRedirects = 10)
        {
            if (!Redirects || !Responses)
            {
                return(false);
            }

            int redirects = 0;

RESTART:

            if (redirects > maxRedirects)
            {
                return(false);
            }

            if (Redirects && Redirects.ContainsKey(GetInternalUrlPostStorageName(URL, POST)))
            {
                URL = Redirects[GetInternalUrlPostStorageName(URL, POST)];
                redirects++;
                goto RESTART;
            }

            if (Responses && Responses.ContainsKey(GetInternalUrlPostStorageName(URL, POST)))
            {
                return(true);
            }

            return(false);
        }
コード例 #5
0
 /// <summary>
 /// 匹配账号密码是否存在且正确
 /// </summary>
 /// <param name="account"></param>
 /// <param name="password"></param>
 /// <returns></returns>
 public bool Match(string account, string password)
 {
     if (!accountModels.ContainsKey(account))
     {
         return(false);
     }
     return(accountModels[account].Password == password);
 }
コード例 #6
0
ファイル: SOBase.cs プロジェクト: wcss2010/SuperCodeFactory
 /// <summary>
 /// 设置扩展属性
 /// 若指定属性不存在,则添加该属性,若指定属性已存在,则修改该属性
 /// </summary>
 /// <param name="name"></param>
 /// <param name="value"></param>
 public virtual void SetValue(string name, object value)
 {
     if (extendProperties.ContainsKey(name))
     {
         extendProperties[name] = value;
     }
     else
     {
         extendProperties.Add(name, value);
     }
 }
コード例 #7
0
 public static DBSchema GetSchemaCached(this IDAC dac)
 {
     using (_schemaCache.EnterWriteScope()) {
         var connectionString = dac.ConnectionString;
         if (!_schemaCache.ContainsKey(connectionString))
         {
             _schemaCache[connectionString] = dac.GetSchema();
         }
         return(_schemaCache[connectionString]);
     }
 }
コード例 #8
0
        private static String FromCache(int contactID, Size photoSize)
        {
            if (_photoCache.ContainsKey(contactID))
            {
                if (_photoCache[contactID].ContainsKey(photoSize))
                {
                    return(_photoCache[contactID][photoSize]);
                }
            }

            return(String.Empty);
        }
コード例 #9
0
        /// <summary>
        /// Подписаться на получение реалтайм данных для инструмента.
        /// </summary>
        /// <param name="security">Инструмент.</param>
        protected virtual void SubscribeSecurity(Security security)
        {
            if (_allSecurity == null && !_securityMap.ContainsKey(security))
            {
                return;
            }

            Connector.RegisterSecurity(security);

            foreach (var tuple in GetDataTypes(security))
            {
                var msgType = tuple.MessageType;

                if (msgType == typeof(QuoteChangeMessage))
                {
                    Connector.RegisterMarketDepth(security);
                }
                //else if (msgType == typeof(Level1ChangeMessage))
                //	Connector.RegisterSecurity(security);
                else if (msgType == typeof(ExecutionMessage))
                {
                    switch ((ExecutionTypes)tuple.Arg)
                    {
                    case ExecutionTypes.Tick:
                        Connector.RegisterTrades(security);
                        break;

                    case ExecutionTypes.Order:
                    case ExecutionTypes.Trade:
                        break;

                    case ExecutionTypes.OrderLog:
                        Connector.RegisterOrderLog(security);
                        break;

                    default:
                        throw new ArgumentOutOfRangeException();
                    }
                }
                else if (msgType.IsCandleMessage())
                {
                    var map = _securityMap.TryGetValue(security);

                    if (map == null)
                    {
                        continue;
                    }

                    _adapter.SendInMessage(new MarketDataMessage
                    {
                        IsSubscribe   = true,
                        SecurityId    = security.ToSecurityId(),
                        DataType      = msgType.ToCandleMarketDataType(),
                        Arg           = tuple.Arg,
                        To            = DateTimeOffset.MaxValue,
                        TransactionId = Connector.TransactionIdGenerator.GetNextId()
                    });
                }
            }
        }
コード例 #10
0
ファイル: AuctionHouse.cs プロジェクト: 0xFh/Asda2-Project
        public void RemoveAuction(Auction auction)
        {
            if (auction == null || !auctions.ContainsKey(auction.AuctionId))
            {
                return;
            }
            auctions.Remove(auction.ItemLowId);
            items.Remove(auction.ItemLowId);
            AuctionMgr instance = Singleton <AuctionMgr> .Instance;
            ItemRecord record   = null;

            if (instance.AuctionItems.ContainsKey(auction.ItemLowId))
            {
                record = instance.AuctionItems[auction.ItemLowId];
                instance.AuctionItems.Remove(auction.ItemLowId);
            }

            ServerApp <RealmServer> .IOQueue.AddMessage(() =>
            {
                if (record != null)
                {
                    record.IsAuctioned = false;
                    record.Save();
                }

                auction.Delete();
            });
        }
コード例 #11
0
        /// <summary>
        /// Parses the XML of the configuration section.
        /// </summary>
        /// <param name="parent">The configuration settings in a corresponding parent configuration section.</param>
        /// <param name="configContext">An HttpConfigurationContext when Create is called from the ASP.NET configuration system. Otherwise, this parameter is reserved and is a null reference.</param>
        /// <param name="section">The XmlNode that contains the configuration information from the configuration file. Provides direct access to the XML contents of the configuration section.</param>
        /// <returns>A configuration object.</returns>
        public object Create(object parent, object configContext, System.Xml.XmlNode section)
        {
            if (section == null)
            {
                throw new ConfigurationErrorsException("The sourceForge/objectFactory section has not been defined.");
            }

            objectDefinitions = new SynchronizedDictionary<string, ObjectDefinition>();

            if (section.HasChildNodes)
            {
                // Register each object's configuration, without the constructor or property information
                foreach (XmlElement element in section.SelectNodes("object"))
                {
                    // In the event of a reference property or constructor argument already being processed, don't process the definition again
                    if (objectDefinitions.ContainsKey(element.GetAttribute("id")) == false)
                    {
                        ObjectDefinition objectDefinition = GetObjectDefinition(section as XmlElement, element, element.GetAttribute("id"));
                        objectDefinitions.Add(objectDefinition.Id, objectDefinition);
                    }
                }
            }

            return this;
        }
コード例 #12
0
        private IDictionary <Jid, UserRosterItemDic> LoadRosterItems()
        {
            var items = new SynchronizedDictionary <Jid, UserRosterItemDic>();

            ExecuteList(new SqlQuery("jabber_roster").Select("jid", "item_jid", "name", "subscription", "ask", "groups"))
            .ForEach(r =>
            {
                var item = new UserRosterItem(new Jid((string)r[1]))
                {
                    Name         = r[2] as string,
                    Subscribtion = (SubscriptionType)Convert.ToInt32(r[3]),
                    Ask          = (AskType)Convert.ToInt32(r[4]),
                };
                if (r[5] != null)
                {
                    item.Groups.AddRange(((string)r[5]).Split(new[] { GroupSeparator }, StringSplitOptions.RemoveEmptyEntries));
                }

                var jid = new Jid((string)r[0]);
                if (!items.ContainsKey(jid))
                {
                    items[jid] = new UserRosterItemDic();
                }
                items[jid][item.Jid] = item;
            });

            return(items);
        }
コード例 #13
0
        public void RemoveAuction(Auction auction)
        {
            if (auction == null)
            {
                return;
            }
            if (!auctions.ContainsKey(auction.AuctionId))
            {
                return;
            }
            auctions.Remove(auction.ItemLowId);
            items.Remove(auction.ItemLowId);
            AuctionMgr mgr    = AuctionMgr.Instance;
            ItemRecord record = null;

            if (mgr.AuctionItems.ContainsKey(auction.ItemLowId))
            {
                record = mgr.AuctionItems[auction.ItemLowId];
                mgr.AuctionItems.Remove(auction.ItemLowId);
            }


            //remove from database
            RealmServer.IOQueue.AddMessage(() => {
                if (record != null)
                {
                    record.IsAuctioned = false;
                    record.Save();
                }
                auction.Delete();
            });
        }
コード例 #14
0
        /// <summary>
        /// Получить или установить обработчик по типу сообщения.
        /// </summary>
        /// <param name="type">Тип сообщения.</param>
        /// <returns>Обработчик.</returns>
        public IMessageProcessor this[MessageTypes type]
        {
            get
            {
                var index = (int)type;
                return(index >= 0 && index < _allProcessors.Length ? _allProcessors[index] : DefaultProcessor);
            }
            set
            {
                lock (_innerDict.SyncRoot)
                {
                    if (_innerDict.ContainsKey(type))
                    {
                        if (_innerDict[type] == value)
                        {
                            return;
                        }

                        Remove(type);
                    }

                    Add(type, value);
                }
            }
        }
        public void TestAddRemoveByKey()
        {
            SynchronizedDictionary <int, string> test = new SynchronizedDictionary <int, string>(new IgnoreLocking());

            for (int i = 0; i < 10; i++)
            {
                test.Add(i, i.ToString());
            }

            for (int i = 0; i < 10; i++)
            {
                Assert.IsTrue(test.ContainsKey(i));
            }

            string cmp;

            for (int i = 0; i < 10; i++)
            {
                Assert.IsTrue(test.TryGetValue(i, out cmp) && cmp == i.ToString());
            }

            for (int i = 0; i < 10; i++)
            {
                Assert.IsTrue(test.Remove(i));
            }
        }
コード例 #16
0
        public void Offline(MobaClient client)
        {
            if (!clientAccDict.ContainsKey(client))
            {
                return;
            }
            string acc = clientAccDict[client];

            if (accClientDict.ContainsKey(acc))
            {
                accClientDict.Remove(acc);
            }
            if (clientAccDict.ContainsKey(client))
            {
                clientAccDict.Remove(client);
            }
        }
コード例 #17
0
        /// <summary>
        /// 下线
        /// </summary>
        /// <param name="client"></param>
        /// <param name="playerId"></param>
        public void Offline(MobaClient client)
        {
            if (!clientIdDict.ContainsKey(client))
            {
                return;
            }
            int id = clientIdDict[client];

            if (clientIdDict.ContainsKey(client))
            {
                clientIdDict.Remove(client);
            }
            if (idClientDict.ContainsKey(id))
            {
                idClientDict.Remove(id);
            }
        }
コード例 #18
0
        public void DictionaryCopyConstructorProperlyCopiesEntriesWithTrackingExplicitlyDisabled()
        {
            var other = new Dictionary <string, string>();

            other.Add("key1", "otherValue1");
            other.Add("key2", "otherValue2");

            var sd = new SynchronizedDictionary <string, string>(other, false);

            Assert.IsTrue(sd.ContainsKey("key1"));
            Assert.IsTrue(sd.ContainsKey("key2"));

            Assert.AreEqual(sd["key1"], "otherValue1");
            Assert.AreEqual(sd["key2"], "otherValue2");
            Assert.IsFalse(sd.TrackAccessed);
            Assert.IsNull(sd.Accessed);
            Assert.IsFalse(sd.TrackGotten);
            Assert.IsNull(sd.Gotten);
        }
コード例 #19
0
        public void AddingKeysDoesNotAffectTrackingStatusOrCollectionsWhenInitiallyDisabled()
        {
            var sd = new SynchronizedDictionary <string, string>();

            sd.Add("key1", "value1");
            sd.Add("key2", "value2");

            // First ensure that items are available
            Assert.IsTrue(sd.ContainsKey("key1"));
            Assert.IsTrue(sd.ContainsKey("key2"));

            // Now ensure that tracking is disabled by default
            Assert.IsFalse(sd.TrackAccessed);
            Assert.IsFalse(sd.TrackGotten);

            // Now ensure that tracking collections are null
            Assert.IsNull(sd.Accessed);
            Assert.IsNull(sd.Gotten);
        }
        public void TestComparer()
        {
            SynchronizedDictionary <string, string> test = new SynchronizedDictionary <string, string>(StringComparer.OrdinalIgnoreCase);

            test["a"] = "b";
            Assert.IsTrue(test.ContainsKey("A"));

            test      = new SynchronizedDictionary <string, string>(StringComparer.OrdinalIgnoreCase, new IgnoreLocking());
            test["a"] = "b";
            Assert.IsTrue(test.ContainsKey("A"));
        }
コード例 #21
0
        /// <summary>
        /// 判断是否存在角色
        /// </summary>
        /// <param name="accountId"></param>
        /// <returns></returns>
        public bool Has(int accountId)
        {
            if (accPlayerDict.ContainsKey(accountId))
            {
                return(true);
            }
            PlayerModel model = new PlayerModel();

            //如果没有那就真的没有
            if (!model.ExistsByAccId(accountId))
            {
                return(false);
            }
            //如果数据库里面存在
            model.GetModelByAccId(accountId);
            //添加到内存里
            accPlayerDict.TryAdd(accountId, model.Id);
            idModelDict.TryAdd(model.Id, model);
            //再进行判断
            return(true);
        }
コード例 #22
0
        public void AccessedTrackingBeginsWhenItIsEnabled()
        {
            var sd = new SynchronizedDictionary <string, string>();

            sd.Add("key1", "value1");
            sd.Add("key2", "value2");

            // Turn on access tracking
            sd.TrackAccessed = true;
            Assert.IsTrue(sd.TrackAccessed);
            Assert.IsNotNull(sd.Accessed);

            sd.ContainsKey("key1");
            Assert.AreEqual(sd.Accessed.Count, 1);
            sd.ContainsKey("key2");
            Assert.AreEqual(sd.Accessed.Count, 2);

            // A second 'access' does not affect count
            sd.ContainsKey("key1");
            Assert.AreEqual(sd.Accessed.Count, 2);
        }
コード例 #23
0
ファイル: ApiPubSub.cs プロジェクト: Wifisoft/teamlab.v6.5
 public void PublishDataForKey(string key, object data)
 {
     if (_handlers.ContainsKey(key))
     {
         IList <DataHandler> handlers = null;
         using (_handlers.GetWriteLock())
         {
             handlers = new List <DataHandler>(_handlers[key]); //Copy
             _handlers[key].Clear();
         }
         //Call
         ThreadPool.QueueUserWorkItem(x =>
         {
             foreach (var handler in handlers)
             {
                 handler.OnDataAvailible(data);
             }
             handlers.Clear();
         });
     }
 }
コード例 #24
0
        public void CopyConstructorProperlyCopiesInstanceIncludingTracking()
        {
            var other = new SynchronizedDictionary <string, string>(true, true);

            other.Add("key1", "otherValue1");
            other.Add("key2", "otherValue2");

            other.ContainsKey("key1");        // Accessed
            var otherValue1 = other["key1"];  // Gotten

            other.ContainsKey("key2");        // Accessed
            var otherValue2 = other["key2"];  // Gotten

            var sd = new SynchronizedDictionary <string, string>(other);

            Assert.IsTrue(sd.TrackAccessed);
            Assert.IsTrue(sd.TrackGotten);

            // As of now we have not accessed or gotten anything from our new clone
            Assert.AreEqual(sd.Accessed.Count, 2); // retains Accessed count from original
            Assert.AreEqual(sd.Gotten.Count, 2);   // retains Gotten count from original
        }
コード例 #25
0
        /// <summary>
        ///    匹配账号密码是否存在正确
        /// </summary>
        /// <returns></returns>
        public bool Match(string acc, string pwd)
        {
            //如果内存有就直接判断
            if (accModelDict.ContainsKey(acc))
            {
                return(accModelDict[acc].Password == pwd);
            }

            AccountModel model = new AccountModel();

            if (!model.Exists(acc))
            {
                return(false);
            }

            //如果数据库存在
            model.GetModel(acc);
            //添加到内存
            accModelDict.TryAdd(model.Account, model);

            return(model.Password == pwd);
        }
コード例 #26
0
        /// <summary>
        /// Подписаться на получение реалтайм данных для инструмента.
        /// </summary>
        /// <param name="security">Инструмент.</param>
        protected virtual void SubscribeSecurity(Security security)
        {
            if (_allSecurity == null && !_securityMap.ContainsKey(security))
            {
                return;
            }

            Connector.RegisterSecurity(security);

            if (CheckSecurity <QuoteChangeMessage>(security))
            {
                Connector.RegisterMarketDepth(security);
            }

            if (CheckSecurity <Trade>(security))
            {
                Connector.RegisterTrades(security);
            }

            if (CheckSecurity <OrderLogItem>(security))
            {
                Connector.RegisterOrderLog(security);
            }

            //if (CheckSecurity<Level1ChangeMessage>(security))
            //	Connector.RegisterSecurity(security);

            if (SupportedCandleSeries.Any())
            {
                var map = _securityMap.TryGetValue(security);

                if (map == null)
                {
                    return;
                }

                foreach (var series in map.CandleSeries)
                {
                    _adapter.SendInMessage(new MarketDataMessage
                    {
                        IsSubscribe   = true,
                        SecurityId    = security.ToSecurityId(),
                        DataType      = series.CandleType.ToCandleMessageType().ToCandleMarketDataType(),
                        Arg           = series.Arg,
                        To            = DateTimeOffset.MaxValue,
                        TransactionId = Connector.TransactionIdGenerator.GetNextId()
                    });
                }
            }
        }
コード例 #27
0
        private void SecurityPicker_OnSecuritySelected(Security security)
        {
            Level1.IsEnabled = Reports.IsEnabled = NewOrder.IsEnabled = Depth.IsEnabled = HistoryCandles.IsEnabled = RealTimeCandles.IsEnabled = security != null;

            if (security == null)
            {
                return;
            }

            Level1.IsChecked          = Trader.RegisteredSecurities.Contains(SelectedSecurity);
            Reports.IsChecked         = _reportSecurities.Contains(SelectedSecurity);
            RealTimeCandles.IsChecked = _сandles.Keys.Any(s => s.Security == SelectedSecurity);
            Depth.IsChecked           = _quotesWindows.ContainsKey(SelectedSecurity);
        }
コード例 #28
0
        /// <summary>
        /// Подписаться на получение реалтайм данных для инструмента.
        /// </summary>
        /// <param name="security">Инструмент.</param>
        protected virtual void SubscribeSecurity(Security security)
        {
            if (_allSecurity == null && !_securityMap.ContainsKey(security))
            {
                return;
            }

            Connector.Connector.RegisterSecurity(security);

            if (CheckSecurity <MarketDepth>(security))
            {
                Connector.Connector.RegisterMarketDepth(security);
            }

            if (CheckSecurity <Trade>(security))
            {
                Connector.Connector.RegisterTrades(security);
            }

            if (CheckSecurity <OrderLogItem>(security))
            {
                Connector.Connector.RegisterOrderLog(security);
            }

            if (CheckSecurity <Level1ChangeMessage>(security))
            {
                Connector.Connector.RegisterSecurity(security);
            }

            if (_isExternalCandleSource)
            {
                var map = _securityMap.TryGetValue(security);

                if (map == null)
                {
                    return;
                }

                var source = (IExternalCandleSource)Connector.Connector;

                foreach (var series in map.CandleSeries)
                {
                    source.SubscribeCandles(new CandleSeries(series.CandleType, security, series.Arg),
                                            DateTimeOffset.MinValue, DateTimeOffset.MaxValue);
                }
            }
        }
コード例 #29
0
        private void SecurityPicker_OnSecuritySelected(Security security)
        {
            Histogram.IsEnabled = Options.IsEnabled = Level1.IsEnabled = Reports.IsEnabled = NewOrder.IsEnabled
                                                                                                 = Depth.IsEnabled = HistoryCandles.IsEnabled = RealTimeCandles.IsEnabled = security != null;

            if (security == null)
            {
                return;
            }

            Options.IsEnabled = security.Type == SecurityTypes.Future || security.Type == SecurityTypes.Option;

            Level1.IsChecked          = Trader.RegisteredSecurities.Contains(SelectedSecurity);
            Reports.IsChecked         = _reportSecurities.ContainsKey(SelectedSecurity);
            Options.IsChecked         = _optionSecurities.ContainsKey(SelectedSecurity);
            RealTimeCandles.IsChecked = _realTimeCandles.Keys.Any(s => s.Security == SelectedSecurity);
            Depth.IsChecked           = _quotesWindows.ContainsKey(SelectedSecurity);
        }
        public void TestLock()
        {
            LockCounterFactory <SimpleReadWriteLocking> factory = new LockCounterFactory <SimpleReadWriteLocking>();
            ILockStrategy lck = factory.Create();
            SynchronizedDictionary <int, string> test = new SynchronizedDictionary <int, string>(lck);

            Assert.IsTrue(ReferenceEquals(lck, test.Lock));
            test.Add(42, "42");
            Assert.AreEqual(1, factory.TotalWriterCount);
            Assert.AreEqual(0, factory.TotalReaderCount);

            test[42] = "51";
            Assert.AreEqual(2, factory.TotalWriterCount);

            test.Add(1, "52");
            Assert.AreEqual(3, factory.TotalWriterCount);

            test.Remove(-1);
            Assert.AreEqual(4, factory.TotalWriterCount);

            test.Remove(1);
            Assert.AreEqual(5, factory.TotalWriterCount);

            Assert.AreEqual("51", test[42]);
            Assert.AreEqual(1, factory.TotalReaderCount);

            foreach (KeyValuePair <int, string> i in test)
            {
                GC.KeepAlive(i);
            }
            Assert.AreEqual(2, factory.TotalReaderCount);

            Assert.AreEqual(false, test.ContainsKey(-1));
            Assert.AreEqual(3, factory.TotalReaderCount);

            Assert.AreEqual(1, test.Count);
            Assert.AreEqual(4, factory.TotalReaderCount);

            string cmp;

            Assert.IsTrue(test.TryGetValue(42, out cmp) && cmp == "51");
            Assert.AreEqual(5, factory.TotalReaderCount);
        }
コード例 #31
0
        private void ProcessSubscribeAction(MarketDataMessage message)
        {
            if (message == null)
            {
                throw new ArgumentNullException("message");
            }

            var key = Tuple.Create(message.SecurityId, message.DataType);

            if (_subscriptionQueue.ContainsKey(key))
            {
                return;
            }

            var enumerator = GetConnectedAdapters().ToArray().Cast <IMessageAdapter>().GetEnumerator();

            _subscriptionQueue.Add(key, new RefPair <IEnumerator <IMessageAdapter>, bool>(enumerator, false));

            ProcessSubscriptionAction(enumerator, message);
        }
コード例 #32
0
ファイル: UnitTest.cs プロジェクト: SolidSnake74/SharpCore
        public void SynchronizedDictionaryUnitTest()
        {
            SynchronizedDictionary<int, string> dictionary = new SynchronizedDictionary<int, string>();

            dictionary.Add(1, "one");
            dictionary.Add(2, "two");
            Assert.IsTrue(dictionary.Count == 2);

            foreach (KeyValuePair<int, string> keyValuePair in dictionary)
            {
                Assert.IsTrue(dictionary.ContainsKey(keyValuePair.Key));
                Assert.IsTrue(dictionary.ContainsValue(keyValuePair.Value));
            }

            dictionary.Remove(1);
            Assert.IsTrue(dictionary.Count == 1);

            dictionary.Clear();
            Assert.IsTrue(dictionary.Count == 0);
        }
コード例 #33
0
        private IDictionary<Jid, UserRosterItemDic> LoadRosterItems()
        {
            var items = new SynchronizedDictionary<Jid, UserRosterItemDic>();

            ExecuteList(new SqlQuery("jabber_roster").Select("jid", "item_jid", "name", "subscription", "ask", "groups"))
                .ForEach(r =>
                {
                    var item = new UserRosterItem(new Jid((string)r[1]))
                    {
                        Name = r[2] as string,
                        Subscribtion = (SubscriptionType)Convert.ToInt32(r[3]),
                        Ask = (AskType)Convert.ToInt32(r[4]),
                    };
                    if (r[5] != null) item.Groups.AddRange(((string)r[5]).Split(new[] { GroupSeparator }, StringSplitOptions.RemoveEmptyEntries));

                    var jid = new Jid((string)r[0]);
                    if (!items.ContainsKey(jid)) items[jid] = new UserRosterItemDic();
                    items[jid][item.Jid] = item;
                });

            return items;
        }