public void CopyTo(KeyValuePair <TKey, TValue>[] array, int arrayIndex) { if (this._genericDictionary != null) { this._genericDictionary.CopyTo(array, arrayIndex); } else { IDictionaryEnumerator enumerator = this._dictionary.GetEnumerator(); try { while (enumerator.MoveNext()) { DictionaryEntry dictionaryEntry = (DictionaryEntry)enumerator.get_Current(); array[arrayIndex++] = new KeyValuePair <TKey, TValue>((TKey)((object)dictionaryEntry.get_Key()), (TValue)((object)dictionaryEntry.get_Value())); } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } } }
private static object CloneValue(object src, Type type) { if (src != null && type != typeof(string) && type.get_IsClass()) { if (!type.get_IsGenericType()) { return(GeneralUtils.CloneClass(src, type)); } if (src is IDictionary) { IDictionary dictionary = src as IDictionary; IDictionary dictionary2 = GeneralUtils.CreateNewType(type) as IDictionary; Type type2 = type.GetGenericArguments()[0]; Type type3 = type.GetGenericArguments()[1]; IDictionaryEnumerator enumerator = dictionary.GetEnumerator(); try { while (enumerator.MoveNext()) { DictionaryEntry dictionaryEntry = (DictionaryEntry)enumerator.get_Current(); dictionary2.Add(GeneralUtils.CloneValue(dictionaryEntry.get_Key(), type2), GeneralUtils.CloneValue(dictionaryEntry.get_Value(), type3)); } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } return(dictionary2); } if (src is IList) { IList list = src as IList; IList list2 = GeneralUtils.CreateNewType(type) as IList; Type type4 = type.GetGenericArguments()[0]; IEnumerator enumerator2 = list.GetEnumerator(); try { while (enumerator2.MoveNext()) { object current = enumerator2.get_Current(); list2.Add(GeneralUtils.CloneValue(current, type4)); } } finally { IDisposable disposable2 = enumerator2 as IDisposable; if (disposable2 != null) { disposable2.Dispose(); } } return(list2); } } return(src); }
private void OnDisable() { if (this.m_ReflectionTexture) { Object.DestroyImmediate(this.m_ReflectionTexture); this.m_ReflectionTexture = null; } if (this.m_RefractionTexture) { Object.DestroyImmediate(this.m_RefractionTexture); this.m_RefractionTexture = null; } using (IDictionaryEnumerator enumerator = this.m_ReflectionCameras.GetEnumerator()) { while (enumerator.MoveNext()) { DictionaryEntry dictionaryEntry = (DictionaryEntry)enumerator.get_Current(); Object.DestroyImmediate(((Camera)dictionaryEntry.get_Value()).get_gameObject()); } } this.m_ReflectionCameras.Clear(); using (IDictionaryEnumerator enumerator2 = this.m_RefractionCameras.GetEnumerator()) { while (enumerator2.MoveNext()) { DictionaryEntry dictionaryEntry2 = (DictionaryEntry)enumerator2.get_Current(); Object.DestroyImmediate(((Camera)dictionaryEntry2.get_Value()).get_gameObject()); } } this.m_RefractionCameras.Clear(); }
public string CallGame(uint callId, LuaTable luatable) { string result2 = string.Empty; if (string.IsNullOrEmpty(luatable["type"].ToString())) { return(result2); } Logger.DEBUG(string.Concat(new object[] { "callId=", callId.ToString(), " type=", luatable["type"] })); Action <string> action = delegate(string result) { CSharpInterface.ExecCallback(callId, result); }; Dictionary <string, object> dictionary = new Dictionary <string, object>(); using (IDictionaryEnumerator enumerator = luatable.GetEnumerator()) { while (enumerator.MoveNext()) { DictionaryEntry dictionaryEntry = (DictionaryEntry)enumerator.get_Current(); dictionary.Add(dictionaryEntry.get_Key().ToString(), dictionaryEntry.get_Value()); } } if (this.callbackForCallGame != null) { result2 = this.callbackForCallGame.Invoke(dictionary, action); } return(result2); }
private static void WriteJson(IJsonWrapper obj, JsonWriter writer) { if (obj.IsString) { writer.Write(obj.GetString()); return; } if (obj.IsBoolean) { writer.Write(obj.GetBoolean()); return; } if (obj.IsDouble) { writer.Write(obj.GetDouble()); return; } if (obj.IsInt) { writer.Write(obj.GetInt()); return; } if (obj.IsLong) { writer.Write(obj.GetLong()); return; } if (obj.IsArray) { writer.WriteArrayStart(); IEnumerator enumerator = obj.GetEnumerator(); try { while (enumerator.MoveNext()) { object current = enumerator.get_Current(); JsonData.WriteJson((JsonData)current, writer); } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } writer.WriteArrayEnd(); return; } if (obj.IsObject) { writer.WriteObjectStart(); IDictionaryEnumerator enumerator2 = obj.GetEnumerator(); try { while (enumerator2.MoveNext()) { DictionaryEntry dictionaryEntry = (DictionaryEntry)enumerator2.get_Current(); writer.WritePropertyName((string)dictionaryEntry.get_Key()); JsonData.WriteJson((JsonData)dictionaryEntry.get_Value(), writer); } } finally { IDisposable disposable2 = enumerator2 as IDisposable; if (disposable2 != null) { disposable2.Dispose(); } } writer.WriteObjectEnd(); return; } }
private void Start() { Component[] componentsInChildren = base.GetComponentsInChildren(typeof(MeshFilter)); Matrix4x4 worldToLocalMatrix = base.get_transform().get_worldToLocalMatrix(); Hashtable hashtable = new Hashtable(); for (int i = 0; i < componentsInChildren.Length; i++) { MeshFilter meshFilter = (MeshFilter)componentsInChildren[i]; Renderer renderer = componentsInChildren[i].get_renderer(); MeshCombineUtility.MeshInstance meshInstance = default(MeshCombineUtility.MeshInstance); meshInstance.mesh = meshFilter.get_sharedMesh(); if (renderer != null && renderer.get_enabled() && meshInstance.mesh != null) { meshInstance.transform = worldToLocalMatrix * meshFilter.get_transform().get_localToWorldMatrix(); Material[] sharedMaterials = renderer.get_sharedMaterials(); for (int j = 0; j < sharedMaterials.Length; j++) { meshInstance.subMeshIndex = Math.Min(j, meshInstance.mesh.get_subMeshCount() - 1); ArrayList arrayList = (ArrayList)hashtable.get_Item(sharedMaterials[j]); if (arrayList != null) { arrayList.Add(meshInstance); } else { arrayList = new ArrayList(); arrayList.Add(meshInstance); hashtable.Add(sharedMaterials[j], arrayList); } } renderer.set_enabled(false); } } using (IDictionaryEnumerator enumerator = hashtable.GetEnumerator()) { while (enumerator.MoveNext()) { DictionaryEntry dictionaryEntry = (DictionaryEntry)enumerator.get_Current(); ArrayList arrayList2 = (ArrayList)dictionaryEntry.get_Value(); MeshCombineUtility.MeshInstance[] combines = (MeshCombineUtility.MeshInstance[])arrayList2.ToArray(typeof(MeshCombineUtility.MeshInstance)); if (hashtable.get_Count() == 1) { if (base.GetComponent(typeof(MeshFilter)) == null) { base.get_gameObject().AddComponent(typeof(MeshFilter)); } if (!base.GetComponent("MeshRenderer")) { base.get_gameObject().AddComponent("MeshRenderer"); } MeshFilter meshFilter2 = (MeshFilter)base.GetComponent(typeof(MeshFilter)); meshFilter2.set_mesh(MeshCombineUtility.Combine(combines, this.generateTriangleStrips)); base.get_renderer().set_material((Material)dictionaryEntry.get_Key()); base.get_renderer().set_enabled(true); } else { GameObject gameObject = new GameObject("Combined mesh"); gameObject.get_transform().set_parent(base.get_transform()); gameObject.get_transform().set_localScale(Vector3.get_one()); gameObject.get_transform().set_localRotation(Quaternion.get_identity()); gameObject.get_transform().set_localPosition(Vector3.get_zero()); gameObject.AddComponent(typeof(MeshFilter)); gameObject.AddComponent("MeshRenderer"); gameObject.get_renderer().set_material((Material)dictionaryEntry.get_Key()); MeshFilter meshFilter3 = (MeshFilter)gameObject.GetComponent(typeof(MeshFilter)); meshFilter3.set_mesh(MeshCombineUtility.Combine(combines, this.generateTriangleStrips)); } } } }
private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth) { if (depth > JsonMapper.max_nesting_depth) { throw new JsonException(string.Format("Max allowed object depth reached while trying to export from type {0}", obj.GetType())); } if (obj == null) { writer.Write(null); return; } if (obj is IJsonWrapper) { if (writer_is_private) { writer.TextWriter.Write(((IJsonWrapper)obj).ToJson()); } else { ((IJsonWrapper)obj).ToJson(writer); } return; } if (obj is string) { writer.Write((string)obj); return; } if (obj is double) { writer.Write((double)obj); return; } if (obj is int) { writer.Write((int)obj); return; } if (obj is bool) { writer.Write((bool)obj); return; } if (obj is long) { writer.Write((long)obj); return; } if (obj is Array) { writer.WriteArrayStart(); IEnumerator enumerator = ((Array)obj).GetEnumerator(); try { while (enumerator.MoveNext()) { object current = enumerator.get_Current(); JsonMapper.WriteValue(current, writer, writer_is_private, depth + 1); } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } writer.WriteArrayEnd(); return; } if (obj is IList) { writer.WriteArrayStart(); IEnumerator enumerator2 = ((IList)obj).GetEnumerator(); try { while (enumerator2.MoveNext()) { object current2 = enumerator2.get_Current(); JsonMapper.WriteValue(current2, writer, writer_is_private, depth + 1); } } finally { IDisposable disposable2 = enumerator2 as IDisposable; if (disposable2 != null) { disposable2.Dispose(); } } writer.WriteArrayEnd(); return; } if (obj is IDictionary) { writer.WriteObjectStart(); IDictionaryEnumerator enumerator3 = ((IDictionary)obj).GetEnumerator(); try { while (enumerator3.MoveNext()) { DictionaryEntry dictionaryEntry = (DictionaryEntry)enumerator3.get_Current(); writer.WritePropertyName((string)dictionaryEntry.get_Key()); JsonMapper.WriteValue(dictionaryEntry.get_Value(), writer, writer_is_private, depth + 1); } } finally { IDisposable disposable3 = enumerator3 as IDisposable; if (disposable3 != null) { disposable3.Dispose(); } } writer.WriteObjectEnd(); return; } Type type = obj.GetType(); if (JsonMapper.custom_exporters_table.ContainsKey(type)) { ExporterFunc exporterFunc = JsonMapper.custom_exporters_table.get_Item(type); exporterFunc(obj, writer); return; } if (JsonMapper.base_exporters_table.ContainsKey(type)) { ExporterFunc exporterFunc2 = JsonMapper.base_exporters_table.get_Item(type); exporterFunc2(obj, writer); return; } if (obj is Enum) { Type underlyingType = Enum.GetUnderlyingType(type); if (underlyingType == typeof(long) || underlyingType == typeof(uint) || underlyingType == typeof(ulong)) { writer.Write((ulong)obj); } else { writer.Write((int)obj); } return; } JsonMapper.AddTypeProperties(type); IList <PropertyMetadata> list = JsonMapper.type_properties.get_Item(type); writer.WriteObjectStart(); using (IEnumerator <PropertyMetadata> enumerator4 = list.GetEnumerator()) { while (enumerator4.MoveNext()) { PropertyMetadata current3 = enumerator4.get_Current(); if (current3.IsField) { writer.WritePropertyName(current3.Info.get_Name()); JsonMapper.WriteValue(((FieldInfo)current3.Info).GetValue(obj), writer, writer_is_private, depth + 1); } else { PropertyInfo propertyInfo = (PropertyInfo)current3.Info; if (propertyInfo.get_CanRead()) { writer.WritePropertyName(current3.Info.get_Name()); JsonMapper.WriteValue(propertyInfo.GetValue(obj, null), writer, writer_is_private, depth + 1); } } } } writer.WriteObjectEnd(); }
private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContract collectionValueContract) { contract.InvokeOnSerializing(values.UnderlyingDictionary, base.Serializer.Context); this.SerializeStack.Add(values.UnderlyingDictionary); writer.WriteStartObject(); bool?isReference = contract.IsReference; bool flag = (!isReference.get_HasValue()) ? this.HasFlag(base.Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects) : isReference.get_Value(); if (flag) { writer.WritePropertyName("$id"); writer.WriteValue(base.Serializer.ReferenceResolver.GetReference(this, values.UnderlyingDictionary)); } if (this.ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract)) { this.WriteTypeProperty(writer, values.UnderlyingDictionary.GetType()); } JsonContract collectionValueContract2 = base.Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object)); int top = writer.Top; IDictionaryEnumerator enumerator = values.GetEnumerator(); try { while (enumerator.MoveNext()) { DictionaryEntry entry = (DictionaryEntry)enumerator.get_Current(); string text = this.GetPropertyName(entry); text = ((contract.PropertyNameResolver == null) ? text : contract.PropertyNameResolver.Invoke(text)); try { object value = entry.get_Value(); JsonContract contractSafe = this.GetContractSafe(value); if (this.ShouldWriteReference(value, null, contractSafe)) { writer.WritePropertyName(text); this.WriteReference(writer, value); } else if (this.CheckForCircularReference(value, default(ReferenceLoopHandling?), contract)) { writer.WritePropertyName(text); this.SerializeValue(writer, value, contractSafe, null, collectionValueContract2); } } catch (Exception ex) { if (!base.IsErrorHandled(values.UnderlyingDictionary, contract, text, ex)) { throw; } this.HandleError(writer, top); } } } finally { IDisposable disposable = enumerator as IDisposable; if (disposable != null) { disposable.Dispose(); } } writer.WriteEndObject(); this.SerializeStack.RemoveAt(this.SerializeStack.get_Count() - 1); contract.InvokeOnSerialized(values.UnderlyingDictionary, base.Serializer.Context); }