C# Hashtable.ContainsKey方法代码示例

    public void SetData(Hashtable ht)
    {
        if(ht.ContainsKey("player")) this.isPlayer = true;
        if(ht.ContainsKey("showname")) this.showName = true;

        this.dialogName = new string[DataHolder.Languages().GetDataCount()];
        for(int i=0; i<this.dialogName.Length; i++)
        {
            this.dialogName[i] = "";
        }

        if(ht.ContainsKey(XMLHandler.NODES))
        {
            if(this.isPlayer) this.overrideName = true;
            ArrayList subs2 = ht[XMLHandler.NODES] as ArrayList;
            foreach(Hashtable ht2 in subs2)
            {
                if(ht2[XMLHandler.NODE_NAME] as string == "name")
                {
                    int id = int.Parse((string)ht2["id"]);
                    if(id < this.dialogName.Length) this.dialogName[id] = ht2[XMLHandler.CONTENT] as string;
                }
            }
        }
    }

    // grabs the contents of the plist and sets them in the ivar
    public void getPlistContents()
    {
        // initialize the hashtable and plistKeys
        plistContents = new Hashtable();

        // get the contents of the plist file if it exists
        filePath = Path.Combine( Application.dataPath, "Editor/Prime31/" + plistFileName );

        if( File.Exists( filePath ) )
        {
            PListEditor.loadPlistFromFile( filePath, plistContents );

            // set any keys that we have present
            var t = typeof( Prime31PlistHelperWizard );
            foreach( var info in t.GetFields() )
            {
                if( plistContents.ContainsKey( info.Name ) )
                {
                    info.SetValue( this, plistContents[info.Name] );
                }
                else if( plistContents.ContainsKey( "CFBundleURLTypes" ) ) // special case for url schemes
                {
                    var values = (ArrayList)plistContents["CFBundleURLTypes"];
                    var ht = values[0] as Hashtable;
                    var listOfSchemes = ht["CFBundleURLSchemes"] as ArrayList;

                    var extractedSchemes = new List<string>();
                    foreach( string scheme in listOfSchemes )
                        extractedSchemes.Add( scheme );

                    CFBundleURLSchemes = extractedSchemes.ToArray();
                }
            }
        }
    }

    public int whichOrder(String[] available, String[] orders)
    {
        Hashtable set = new Hashtable();
        int k = 0;
        foreach (String s in available)
        {
            if(!set.ContainsKey(s))
            set.Add(s, k++);
        }
        for (int i = 0; i < orders.Length; ++i)
        {
            string[] ins = orders[i].Split(new char[] { ' ' });
            bool isOk = true;
            foreach (String ss in ins)
            {
                if (!set.ContainsKey(ss))
                {
                    isOk = false;
                    break;
                }

            }
            if (isOk)
            {
                return i;
            }
        }
        return -1;
    }

    /// <summary>
    /// Reads all necessary mesh information
    /// </summary>
    public void ReadMesh()
    {
        Hashtable Hash=new Hashtable();
        List<Vector3> pts = new List<Vector3>();
        if (Mesh != mOldMesh || Transform.rotation != mOldRot || Scale != mOldScale) {
            if (Mesh) {
                int[] tris = Mesh.sharedMesh.triangles;
                Vector3[] verts = Mesh.sharedMesh.vertices;
                for (int i = 0; i < verts.Length; i++)
                    verts[i].Scale(Scale);

                for (int t = 0; t < tris.Length; t += 3) {
                    if (!Hash.ContainsKey(Key(tris[t], tris[t + 1]))) {
                        Hash.Add(Key(tris[t], tris[t + 1]), null);
                        pts.Add(verts[tris[t]]);
                        pts.Add(verts[tris[t + 1]]);
                    }
                    if (!Hash.ContainsKey(Key(tris[t + 1], tris[t + 2]))) {
                        Hash.Add(Key(tris[t + 1], tris[t + 2]), null);
                        pts.Add(verts[tris[t + 1]]);
                        pts.Add(verts[tris[t + 2]]);
                    }
                    if (!Hash.ContainsKey(Key(tris[t + 2], tris[t]))) {
                        Hash.Add(Key(tris[t + 2], tris[t]), null);
                        pts.Add(verts[tris[t + 2]]);
                        pts.Add(verts[tris[t]]);
                    }
                }
            }
            mOldMesh = Mesh;
            mOldRot = Transform.rotation;
            mOldScale = Scale;
            Points = pts.ToArray();
        }
    }

        public void TestGetKeyValueList()
        {
            var dic1 = new SortedList();

            for (int i = 0; i < 100; i++)
                dic1.Add("Key_" + i, "Value_" + i);

            var ilst1 = dic1.GetKeyList();
            var hsh1 = new Hashtable();

            DoIListTests(dic1, ilst1, hsh1, DicType.Key);

            Assert.False(hsh1.Count != 2
                || !hsh1.ContainsKey("IsReadOnly")
                || !hsh1.ContainsKey("IsFixedSize"), "Error, KeyList");


            dic1 = new SortedList();
            for (int i = 0; i < 100; i++)
                dic1.Add("Key_" + i, "Value_" + i);

            ilst1 = dic1.GetValueList();
            hsh1 = new Hashtable();
            DoIListTests(dic1, ilst1, hsh1, DicType.Value);

            Assert.False(hsh1.Count != 2
                || !hsh1.ContainsKey("IsReadOnly")
                || !hsh1.ContainsKey("IsFixedSize"), "Error, ValueList");
        }

        public void TestCtorDictionarySingle()
        {
            // No exception
            var hash = new Hashtable(new Hashtable(), 1f);
            // No exception
            hash = new Hashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable(new Hashtable()), 1f), 1f), 1f), 1f);

            // []test to see if elements really get copied from old dictionary to new hashtable
            Hashtable tempHash = new Hashtable();
            // this for assumes that MinValue is a negative!
            for (long i = long.MinValue; i < long.MinValue + 100; i++)
            {
                tempHash.Add(i, i);
            }

            hash = new Hashtable(tempHash, 1f);

            // make sure that new hashtable has the elements in it that old hashtable had
            for (long i = long.MinValue; i < long.MinValue + 100; i++)
            {
                Assert.True(hash.ContainsKey(i));
                Assert.True(hash.ContainsValue(i));
            }

            //[]make sure that there are no connections with the old and the new hashtable
            tempHash.Clear();
            for (long i = long.MinValue; i < long.MinValue + 100; i++)
            {
                Assert.True(hash.ContainsKey(i));
                Assert.True(hash.ContainsValue(i));
            }
        }

    public static SceneData.SceneNodeData CreateNodeData( Hashtable attrTable )
    {
        SceneData.SceneNodeData data = new SceneData.SceneNodeData();
        data.name = attrTable["name"] as string;
        data.parentname = attrTable["parentname"] as string;

        ParamUtil.SetFloatAttr( out data.posX , "posX" , attrTable , 0f );
        ParamUtil.SetFloatAttr( out data.posY , "posY" , attrTable , 0f );
        ParamUtil.SetFloatAttr( out data.posZ , "posZ" , attrTable , 0f );

        ParamUtil.SetFloatAttr( out data.rotX , "rotX" , attrTable , 0f );
        ParamUtil.SetFloatAttr( out data.rotY , "rotY" , attrTable , 0f );
        ParamUtil.SetFloatAttr( out data.rotZ , "rotZ" , attrTable , 0f );

        ParamUtil.SetFloatAttr( out data.sclX , "sclX" , attrTable , 1f );
        ParamUtil.SetFloatAttr( out data.sclY , "sclY" , attrTable , 1f );
        ParamUtil.SetFloatAttr( out data.sclZ , "sclZ" , attrTable , 1f );

        data.uiAtlasName = attrTable["uiAtlasName"] as string;
        data.texturePath = attrTable["texturePath"] as string;
        ParamUtil.SetFloatAttr( out data.alpha , "alpha" , attrTable , 1f );
        if( attrTable.ContainsKey( "show") ){
            data.show = ViNoStringExtensions.IsTrueOrYes( attrTable["show"] as string  );
        }
        if( attrTable.ContainsKey( "makePixelPerfect") ){
            data.makePixelPerfect = ViNoStringExtensions.IsTrueOrYes( attrTable["makePixelPerfect"] as string  );
        }
        return data;
    }

 public void SetData(Hashtable ht)
 {
     if(ht.ContainsKey("itemchance"))
     {
         this.stealItem = true;
         this.itemChance = int.Parse((string)ht["itemchance"]);
         this.itemBonus = float.Parse((string)ht["itembonus"]);
         if(ht.ContainsKey("item"))
         {
             this.fixItem = true;
             this.itemType = (ItemDropType)System.Enum.Parse(
                     typeof(ItemDropType), (string)ht["itemtype"]);
             this.itemID = int.Parse((string)ht["item"]);
         }
     }
     if(ht.ContainsKey("moneychance"))
     {
         this.stealMoney = true;
         this.moneyChance = int.Parse((string)ht["moneychance"]);
         this.moneyBonus = float.Parse((string)ht["moneybonus"]);
         if(ht.ContainsKey("money"))
         {
             this.fixMoney = true;
             this.money = int.Parse((string)ht["money"]);
         }
     }
 }

	//////////////////////////////////////////
	/// ID_SimilarityBucket()
	//////////////////////////////////////////
	public ID_Audio( string i_strID, Hashtable hashData, List<IXMLNode> listElements, string strError ) {
		if ( hashData.ContainsKey( "Volume" ) )
			m_fVolume = float.Parse(hashData["Volume"].ToString());

		if ( hashData.ContainsKey( "Loop" ) )
			m_bLoop = bool.Parse(hashData["Loop"].ToString());
	}	

	public void Populate (Hashtable data)
	{
		if(data == null)
			return;

		if(data.ContainsKey("listAutomotor"))
			SetVehicles (data ["listAutomotor"] as ArrayList);
		if(data.ContainsKey("grupoAutomotores"))
			SetVehiclesGroup (data ["grupoAutomotores"] as ArrayList);
	}

    public static StoreKitDownload downloadFromHashtable( Hashtable ht )
    {
        var download = new StoreKitDownload();
		
		if( ht.ContainsKey( "downloadState" ) )
        	download.downloadState = (StoreKitDownloadState)int.Parse( ht["downloadState"].ToString() );
		
		if( ht.ContainsKey( "contentLength" ) )
        	download.contentLength = double.Parse( ht["contentLength"].ToString() );
		
		if( ht.ContainsKey( "contentIdentifier" ) )
        	download.contentIdentifier = ht["contentIdentifier"].ToString();
		
		if( ht.ContainsKey( "contentURL" ) )
        	download.contentURL = ht["contentURL"].ToString();
		
		if( ht.ContainsKey( "contentVersion" ) )
			download.contentVersion = ht["contentVersion"].ToString();
		
		if( ht.ContainsKey( "error" ) )
			download.error = ht["error"].ToString();
		
		if( ht.ContainsKey( "progress" ) )
			download.progress = float.Parse( ht["progress"].ToString() );
		
		if( ht.ContainsKey( "timeRemaining" ) )
        	download.timeRemaining = double.Parse( ht["timeRemaining"].ToString() );
		
		if( ht.ContainsKey( "transaction" ) )
        	download.transaction = StoreKitTransaction.transactionFromHashtable( ht["transaction"] as Hashtable );

        return download;
    }

 public void HashContain()
 {
     Hashtable<string, int> phonebook = new Hashtable<string, int>(100);
     phonebook.Add("Razvan Hidan", 0744596712);
     phonebook.Add("Ionut Marin", 076653421);
     phonebook.Add("Bogdan Dragos", 07111111);
     phonebook.Add("Maria Marioara", 0783442);
     phonebook.ContainsKey("Razvan Hidan");
     phonebook.ContainsKey("Bogdan Dragos");
     phonebook.ContainsKey("Razvan").ShouldBeFalse();
 }

        public void TestContainKeyBasic()
        {
            StringBuilder sblMsg = new StringBuilder(99);

            Hashtable ht1 = null;

            string s1 = null;
            string s2 = null;

            int i = 0;

            ht1 = new Hashtable(); //default constructor
            Assert.False(ht1.ContainsKey("No_Such_Key"));

            // add few key-val pairs
            ht1 = new Hashtable();
            for (i = 0; i < 100; i++)
            {
                sblMsg = new StringBuilder(99);
                sblMsg.Append("key_");
                sblMsg.Append(i);
                s1 = sblMsg.ToString();

                sblMsg = new StringBuilder(99);
                sblMsg.Append("val_");
                sblMsg.Append(i);
                s2 = sblMsg.ToString();
                ht1.Add(s1, s2);
            }

            for (i = 0; i < ht1.Count; i++)
            {
                sblMsg = new StringBuilder(99);
                sblMsg.Append("key_");
                sblMsg.Append(i);
                s1 = sblMsg.ToString();

                Assert.True(ht1.ContainsKey(s1));
            }

            //
            // [] Remove a key and then check
            //
            sblMsg = new StringBuilder(99);
            sblMsg.Append("key_50");
            s1 = sblMsg.ToString();

            ht1.Remove(s1); //removes "Key_50"

            //check whether the key is removed or not
            Assert.False(ht1.ContainsKey(s1));
        }

 public void SetData(Hashtable ht)
 {
     this.name = ht[XMLHandler.CONTENT] as string;
     if(ht.ContainsKey("id"))
     {
         this.layer = int.Parse((string)ht["id"]);
     }
     if(ht.ContainsKey("speed"))
     {
         this.setSpeed = true;
         this.speedFormula = int.Parse((string)ht["speed"]);
     }
 }

 /*
 ["creatorName"]
 ["position"]
 ["rotation"]
 */
 public void create(Hashtable p)
 {
     Vector3 position = new Vector3();
     Quaternion rotation = new Quaternion();
     if (p.ContainsKey("position"))
         position = (Vector3)p["position"] ;
     if (p.ContainsKey("rotation"))
         rotation = (Quaternion)p["rotation"];
     GameObject clone = zzCreatorUtility.Instantiate((GameObject)creatorMap[p["creatorName"]], position, rotation, 0);
     Debug.Log(p["creatorName"] + " " + clone.name);
     zzGameObjectInit initObject = clone.GetComponent<zzGameObjectInit>();
     initObject.init(p);
 }