C# Dict.ContainsKey方法代码示例

    static List<AssetBundleBuild> GeneratorAssetbundleEntry()
    {
        string path = Application.dataPath + "/" + PackagePlatform.packageConfigPath;
        if (string.IsNullOrEmpty(path)) return null;

        string str = File.ReadAllText(path);

        Dict<string, ABEntry> abEntries = new Dict<string, ABEntry>();

        PackageConfig apc = JsonUtility.FromJson<PackageConfig>(str);

        AssetBundlePackageInfo[] bundlesInfo = apc.bundles;

        for (int i = 0; i < bundlesInfo.Length; i++)
        {
            ABEntry entry = new ABEntry();
            entry.bundleInfo = bundlesInfo[i];

            if (!abEntries.ContainsKey(entry.bundleInfo.name))
            {
                abEntries.Add(entry.bundleInfo.name, entry);
            }
        }

        List<AssetBundleBuild> abbList = new List<AssetBundleBuild>();
        foreach (var rEntryItem in abEntries)
        {
            abbList.AddRange(rEntryItem.Value.ToABBuild());
        }
        return abbList;
    }

 public void ItShouldAdd()
 {
     Dict<int, string> test = new Dict<int, string>();
     test.Add(1, "One");
     test.Add(2, "Two");
     test.Add(3, "Three");
     test.Add(4, "Four");
     test.Add(5, "Five");
     bool actual = test.ContainsKey(1);
     bool expected = true;
     Assert.AreEqual(expected, actual);
 }

 public void ItShouldRemove()
 {
     Dict<int, string> test = new Dict<int, string>();
     test.Add(1, "One");
     test.Add(2, "Two");
     test.Add(3, "Three");
     test.Add(4, "Four");
     test.Add(5, "Five");
     test.Add(18, "Eightteen");
     test.Remove(3);
     bool actual=test.ContainsKey(3);
     bool expected=false;
     Assert.AreEqual(expected, actual);
 }

 /// <summary>
 /// Return a dict that maps slot names to slot values, but only include slots that have been assigned to.
 /// Looks up slots in base types as well as the current type.
 /// 
 /// Sort-of Python equivalent (doesn't look up base slots, while the real code does):
 ///   return dict([(slot, getattr(self, slot)) for slot in type(self).__slots__ if hasattr(self, slot)])
 /// 
 /// Return null if the object has no __slots__, or empty dict if it has __slots__ but none are initialized.
 /// </summary>
 private static Dict GetInitializedSlotValues(object obj)
 {
     Dict initializedSlotValues = new Dict();
     Tuple mro = Ops.GetDynamicType(obj).MethodResolutionOrder;
     object slots;
     object slotValue;
     foreach (object type in mro) {
         if (Ops.TryGetAttr(type, SymbolTable.Slots, out slots)) {
             List<string> slotNames = IronPython.Compiler.Generation.NewTypeMaker.SlotsToList(slots);
             foreach (string slotName in slotNames) {
                 if (slotName == "__dict__") continue;
                 // don't reassign same-named slots from types earlier in the MRO
                 if (initializedSlotValues.ContainsKey(slotName)) continue;
                 if (Ops.TryGetAttr(obj, SymbolTable.StringToId(slotName), out slotValue)) {
                     initializedSlotValues[slotName] = slotValue;
                 }
             }
         }
     }
     if (initializedSlotValues.Count == 0) return null;
     return initializedSlotValues;
 }

 internal IDictionary<object, object> GetAttrDict(ICallerContext context)
 {
     if (HaveInterfaces) {
         Dict res = new Dict();
         foreach (DynamicType type in interfaces) {
             Dict dict = type.GetAttrDict(context, obj);
             foreach (KeyValuePair<object, object> val in dict) {
                 if (!res.ContainsKey(val.Key)) {
                     res.Add(val);
                 }
             }
         }
         return res;
     } else {
         return new Dict(0);
     }
 }

 protected FrozenSetCollection(object set)
 {
     IEnumerator setData = Ops.GetEnumerator(set);
     items = new Dict();
     while (setData.MoveNext()) {
         object o = setData.Current;
         if (!items.ContainsKey(o)) {
             items.Add(o, o);
         }
     }
     CalculateHashCode();
 }

        public virtual Dict GetAttrDict(ICallerContext context, object self)
        {
            // Get the entries from the type
            Dict res = new Dict(GetAttrDict(context));

            // Add the entries from the instance
            ISuperDynamicObject sdo = self as ISuperDynamicObject;
            if (sdo != null) {
                IAttributesDictionary dict = sdo.GetDict();
                if (dict != null) {
                    foreach (KeyValuePair<object, object> val in dict) {
                        object fieldName = val.Key;
                        if (!res.ContainsKey(fieldName)) {
                            res.Add(new KeyValuePair<object, object>(fieldName, val.Value));
                        }
                    }
                }
            }
            return res;
        }

 public static string Translate(string self, Dict table)
 {
     if (table == null) throw Ops.TypeError("expected dictionary or string, got NoneType");
     if (self.Length == 0) return self;
     StringBuilder ret = new StringBuilder();
     for (int i = 0, idx = 0; i < self.Length; i++) {
         idx = (int)self[i];
         if (table.ContainsKey(idx))
             ret.Append((string)table[idx]);
         else
             ret.Append(self[i]);
     }
     return ret.ToString();
 }

        /// <summary>
        /// Extracts the meta tag info from the page using RegEx
        /// </summary>
        /// <param name="p_strPageHtmlContent"></param>
        /// <returns>Deprecated</returns>
        private static Dict<string, PageMeta> GetPageMetaInfo(string p_strPageHtmlContent)
        {
            Dict<string, PageMeta> dictReturnSet = new Dict<string, PageMeta>();
            PageMeta pmMetaTag = new PageMeta();

            //   Try grabbing the meta info of the page into a dictionary
            string pattern = "<meta.+?(?:name=(?:\"|')(.*?)(?:\"|').*?)?(?:property=(?:\"|')(.*?)(?:\"|').*?)?(?:content=(?:\"|')(.*?)(?:\"|'))?/?>.*?</head>";
            RegexOptions rxoOptions = RegexOptions.IgnoreCase | RegexOptions.Singleline;

            foreach (Match match in Regex.Matches(p_strPageHtmlContent, pattern, rxoOptions))
            {
                pmMetaTag = new PageMeta();
                pmMetaTag.Name = match.Groups[1].Value;
                pmMetaTag.Property = match.Groups[2].Value;
                pmMetaTag.Content = match.Groups[3].Value;
                if (!dictReturnSet.ContainsKey(match.Groups[1].Value))
                {
                    dictReturnSet.Add(match.Groups[1].Value, pmMetaTag);
                }
            }

            return dictReturnSet;
        }