C# ReadOnlyDictionary.ContainsKey方法代码示例

        public void ConstructorKeySelector()
        {
            var dict = new ReadOnlyDictionary<int, DateTime> (new[]{
                new DateTime (2009, 1, 1),
                new DateTime (2008, 1, 1),
                new DateTime (2007, 1, 1)
            }.ToDictionary(d => d.Year));

            Assert.IsTrue (dict.ContainsKey (2009));
            Assert.IsTrue (dict.ContainsKey (2008));
            Assert.IsTrue (dict.ContainsKey (2007));
        }

        public void TestConstructBaseDictionaryChanged()
        {
            var basedic = new Dictionary<string, string>() {
            {"key1", "val1"},
            {"key2", "val2"},
            {"key3", "val3"},
              };
              var dic = new ReadOnlyDictionary<string, string>(basedic);

              Assert.IsTrue(dic.IsReadOnly);
              Assert.IsTrue(dic.ContainsKey("key1"));
              Assert.IsFalse(dic.ContainsKey("key4"));

              basedic.Add("key4", "val4");

              Assert.IsTrue(dic.ContainsKey("key4"));
        }

		/// <summary>
		/// 次のレベルに上がるのに必要な経験値の量を取得します。
		/// </summary>
		/// <param name="expTable">経験値テーブル。</param>
		/// <param name="current">現在の累積経験値。</param>
		private static int GetNextExp( ReadOnlyDictionary<int, Experience> expTable, int current ) {

			Experience l = expTable.Values.FirstOrDefault( e => e.Total + e.Next > current );

			if ( l == null || !expTable.ContainsKey( l.Level + 1 ) )
				return 0;

			return expTable[l.Level + 1].Total - current;
		}

 private static void TryAdd(ReadOnlyDictionary<string, string> dictionary, List<string> parts, string key)
 {
     if (dictionary.ContainsKey(key))
         parts.Add(dictionary[key]);
 }

 public static void ThrowIfNotFound(ReadOnlyDictionary<string, string> dictionary, string data, string key)
 {
     if (dictionary.ContainsKey(key))
         return;
     throw new KeyNotFoundException($"The key '{key}' is missing in '{data}'");
 }

        private static void TryMinifyNumberWithUnit(NumberWithUnitValue value, ReadOnlyDictionary<Unit, decimal> possibleConversions, ref NumberWithUnitValue smallest)
        {
            if (!possibleConversions.ContainsKey(value.Unit)) return;

            var min = MinifyNumberValue(value);

            var ret = new NumberWithUnitValue(min.Value, value.Unit);
            string retStr;
            using (var buffer = new StringWriter())
            {
                ret.Write(buffer);
                retStr = buffer.ToString();
            }

            var inBasic = min.Value * possibleConversions[value.Unit];

            foreach (var unit in possibleConversions.Keys)
            {
                var conversion = possibleConversions[unit];

                var maxPrecision = inBasic / conversion;

                // 5 decimal points seems like an acceptable level of precision; webkit seems to agree
                var inUnit = decimal.Round(maxPrecision, 5);

                var asNum = new NumberValue(inUnit);
                var minified = MinifyNumberValue(asNum);

                var newMin = new NumberWithUnitValue(minified.Value, unit);
                string newMinStr;

                using (var buffer = new StringWriter())
                {
                    newMin.Write(buffer);
                    newMinStr = buffer.ToString();
                }

                if (newMinStr.Length < retStr.Length)
                {
                    ret = newMin;
                    retStr = newMinStr;
                }
            }

            smallest = ret;
        }

    IDisposable key_correlator_replay(DDS.DomainParticipant participant, bool useLinq)
    {
        int MAX_COLORS = 8;

        var rx_square_reader =
        DDSObservable.FromKeyedTopic<string, ShapeTypeExtended>(participant, "Square", shape => shape.color);

        var dictionary = new Dictionary<string, string>();
        dictionary.Add("PURPLE", "BLUE");
        dictionary.Add("RED", "GREEN");
        dictionary.Add("YELLOW", "CYAN");
        dictionary.Add("MAGENTA", "ORANGE");

        var associations = new ReadOnlyDictionary<string, string>(dictionary);

        var cache = rx_square_reader.Replay();
        cache.Connect();

        if (useLinq)
        {
          return
          (from group1 in cache.Where(groupedSq => associations.ContainsKey(groupedSq.Key))
           from group2 in cache.Take(MAX_COLORS)
           where associations[group1.Key] == group2.Key
           select new { k1 = group1, k2 = group2 })
            .Subscribe(pair =>
            {
              Console.WriteLine("MATCH {0}--{1}", pair.k1.Key, pair.k2.Key);
              pair.k1.CombineLatest(pair.k2,
                                   (a, b) =>
                                   {
                                     return new ShapeTypeExtended
                                     {
                                       x = (int)((a.x + b.x) / 2),
                                       y = (int)((a.y + b.y) / 2),
                                       color = a.color,
                                       shapesize = a.shapesize
                                     };
                                   })
                     .Subscribe(triangle_writer);
            });
        }
        else
        {
          return
        cache
           .Where(groupedSq => associations.ContainsKey(groupedSq.Key))
           .SelectMany(groupedSq => cache.Take(MAX_COLORS),
                      (groupedSq, cached_groupedSq) =>
                      {
                        if (associations[groupedSq.Key] == cached_groupedSq.Key)
                        {
                          Console.WriteLine("MATCH {0} -- {1}", groupedSq.Key, cached_groupedSq.Key);
                          groupedSq
                            .CombineLatest(cached_groupedSq,
                                          (a, b) =>
                                          {
                                            return new ShapeTypeExtended
                                            {
                                              x = (int)((a.x + b.x) / 2),
                                              y = (int)((a.y + b.y) / 2),
                                              color = a.color,
                                              shapesize = a.shapesize
                                            };
                                          })
                            .Subscribe(triangle_writer);
                        }
                        else
                          Console.WriteLine("NO-MATCH {0} -- {1}", groupedSq.Key, cached_groupedSq.Key);

                        return (IGroupedObservable<string, ShapeTypeExtended>)groupedSq;
                      }).Subscribe();
        }
    }

		/// <summary>
		/// 指定したレベルに上がるのに必要な経験値の量を取得します。
		/// </summary>
		/// <param name="expTable">経験値テーブル。</param>
		/// <param name="current">現在の累積経験値。</param>
		/// <param name="level">対象のレベル。</param>
		private static int GetExpToLevel( ReadOnlyDictionary<int, Experience> expTable, int current, int level ) {

			if ( !expTable.ContainsKey( level ) )
				return 0;

			return expTable[level].Total - current;
		}

		private static FileInfo[] GetFileInfo(ReadOnlyDictionary<long, ReadOnlyCollection<FileInfo>> names, long awbId)
		{
			return names != null && names.ContainsKey(awbId) ? names[awbId].ToArray() : null;
		}

        /// <summary>
        /// Takes a snapshot of the child signals before making a change, then makes the change, then takes another
        /// snapshot, does a comparison, and fires a signal changed event for any signals that are different.
        /// </summary>
        /// <param name="act">Action that does changes to the tree</param>
        public void NotifySignals(Action act)
        {
            var oldChildren = new ReadOnlyDictionary<FieldGuid, NodeBase>(new Dictionary<FieldGuid, NodeBase>());
            if (Node != null)
            {
                oldChildren = Node.GetChildrenRecursive();
            }

            act();

            var newChildren = new ReadOnlyDictionary<FieldGuid, NodeBase>(new Dictionary<FieldGuid, NodeBase>());
            if (Node != null)
            {
                newChildren = Node.GetChildrenRecursive();
            }

            foreach (var newChildKey in newChildren.Keys)
            {
                if (!oldChildren.ContainsKey(newChildKey))
                {
                    // it's an edited node
                    var sig = newChildren[newChildKey] as NodeSignal;
                    runtimeService.NotifySignalChanged(sig);
                }
            }
        }

        public void TestReadOperations()
        {
            var dic = new ReadOnlyDictionary<string, string>(new Dictionary<string, string>() {
            {"key1", "val1"},
            {"key2", "val2"},
            {"key3", "val3"},
              });

              Assert.AreEqual(3, dic.Count);

              Assert.AreEqual("val1", dic["key1"]);
              Assert.IsTrue(dic.Contains(new KeyValuePair<string, string>("key2", "val2")));
              Assert.IsTrue(dic.ContainsKey("key3"));

              foreach (var pair in dic) {
              }

              foreach (var key in dic.Keys) {
              }

              foreach (var val in dic.Values) {
              }

              var pairs = new KeyValuePair<string, string>[3];

              dic.CopyTo(pairs, 0);

              string outval = null;

              Assert.IsTrue(dic.TryGetValue("key1", out outval));
              Assert.AreEqual(outval, "val1");
        }

        public void ReadOnlyDictionary_Unit_ContainsKey_Optimal()
        {
            IDictionary<String, String> dictionary = new Dictionary<String, String>() {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
                { "Key3", "Value3" }
            };
            ReadOnlyDictionary<String, String> target = new ReadOnlyDictionary<String, String>(dictionary);
            String key = dictionary.Keys.First();

            Boolean actual = target.ContainsKey(key);
            Assert.AreEqual(true, actual);
        }

        public void ReadOnlyDictionary_Unit_ContainsKey_KeyIsNull()
        {
            IDictionary<String, String> dictionary = new Dictionary<String, String>() {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
                { "Key3", "Value3" }
            };
            ReadOnlyDictionary<String, String> target = new ReadOnlyDictionary<String, String>(dictionary);
            String key = null;

            target.ContainsKey(key);
        }

        public void ReadOnlyDictionary_Unit_ContainsKey_KeyDoesNotExist()
        {
            IDictionary<String, String> dictionary = new Dictionary<String, String>() {
                { "Key1", "Value1" },
                { "Key2", "Value2" },
                { "Key3", "Value3" }
            };
            ReadOnlyDictionary<String, String> target = new ReadOnlyDictionary<String, String>(dictionary);
            String key = "MyKey";

            Boolean actual = target.ContainsKey(key);
            Assert.AreEqual(false, actual);
        }