public wrapperStatic compile() { wrapperStatic _wrapperStatic; if (!this.compiled) { // generar un archivo por cada tipo string name = GetSHA1(this.type.AssemblyQualifiedName).ToUpper(); string file = environment.getCompilationFile(name); FileInfo f = new FileInfo(file); try { if (f.Exists) { string str = "C" + GetSHA1(type.AssemblyQualifiedName); string str1 = "C" + GetSHA1(type.AssemblyQualifiedName) + "_static"; Type _type = Assembly.LoadFile(file).GetType(string.Concat("jxshell.dotnet4.", str1)); ConstructorInfo _constructor = _type.GetConstructor(new Type[] { typeof(Type), typeof(typeDescriptor) }); this.compiledWrapper = (wrapperStatic)_constructor.Invoke(new object[] { this.type, this }); this.compiled = true; } else { StringBuilder stringBuilder = new StringBuilder(); string str = ""; string str1 = ""; typeDescriptor.addUsingsStatements(stringBuilder); this.precompile(stringBuilder, ref str, ref str1); stringBuilder.AppendLine("class program{public static void main(){}}"); csharplanguage _csharplanguage = typeDescriptor.language; _csharplanguage.runScriptWithId(stringBuilder.ToString(), name); Type _type = _csharplanguage.getCompiledAssembly().GetType(string.Concat("jxshell.dotnet4.", str)); ConstructorInfo _constructor = _type.GetConstructor(new Type[] { typeof(Type), typeof(typeDescriptor) }); this.compiledWrapper = (wrapperStatic)_constructor.Invoke(new object[] { this.type, this }); this.compiled = true; } } catch (Exception exception1) { Exception exception = exception1; throw new Exception(string.Concat("No se puede obtener un wrapper para el tipo ", this.type.ToString(), ". ", exception.Message), exception); } _wrapperStatic = this.compiledWrapper; } else { _wrapperStatic = this.compiledWrapper; } return(_wrapperStatic); }
public void loadManyTypes(string types) { string[] array = types.Split(new string[] { "-" }, StringSplitOptions.RemoveEmptyEntries); StringBuilder stringBuilder = new StringBuilder(); typeDescriptor.addUsingsStatements(stringBuilder); Dictionary <Type, type_1> dictionary = new Dictionary <Type, type_1>(); string[] array2 = array; for (int i = 0; i < array2.Length; i++) { string typeName = array2[i]; Type typeOrGenericType = this.getTypeOrGenericType(typeName); typeDescriptor typeDescriptor = new typeDescriptor(typeOrGenericType, typeName, false); if (!typeDescriptor.isCompiled()) { string staticClass = ""; string instanceClass = ""; typeDescriptor.precompile(stringBuilder, ref staticClass, ref instanceClass); dictionary[typeOrGenericType] = new type_1 { td = typeDescriptor, staticClass = staticClass, instanceClass = instanceClass, t = typeOrGenericType }; } } stringBuilder.AppendLine("class program{public static void main(){}}"); csharplanguage csharplanguage = (csharplanguage)language.defaultLanguage.create(); if (dictionary.Count > 0) { csharplanguage.runScript(stringBuilder.ToString(), typeDescriptor.generateInMemory); } foreach (KeyValuePair <Type, type_1> current in dictionary) { type_1 value = current.Value; Type type = csharplanguage.getCompiledAssembly().GetType("jxshell.dotnet4." + value.staticClass); ConstructorInfo constructor = type.GetConstructor(new Type[] { typeof(Type), typeof(typeDescriptor) }); value.td.setCompiledWrapper((wrapperStatic)constructor.Invoke(new object[] { value.t, value.td })); } }
public wrapperStatic compile() { wrapperStatic result; if (this.compiled) { result = this.compiledWrapper; } else { StringBuilder stringBuilder = new StringBuilder(); string str = ""; string text = ""; typeDescriptor.addUsingsStatements(stringBuilder); this.precompile(stringBuilder, ref str, ref text); stringBuilder.AppendLine("class program{public static void main(){}}"); try { csharplanguage csharplanguage = typeDescriptor.language; //Clipboard.SetText(stringBuilder.ToString()); csharplanguage.runScript(stringBuilder.ToString(), typeDescriptor.generateInMemory); Type type = csharplanguage.getCompiledAssembly().GetType("jxshell.dotnet4." + str); ConstructorInfo constructorInfo = type.GetConstructor(new Type[] { typeof(Type), typeof(typeDescriptor) }); this.compiledWrapper = (wrapperStatic)constructorInfo.Invoke(new object[] { this.type, this }); this.compiled = true; } catch (Exception ex) { throw new Exception("No se puede obtener un wrapper para el tipo " + this.type.ToString() + ". " + ex.Message, ex); } result = this.compiledWrapper; } return(result); }
public typeDescriptor(Type t, string typeName, bool compile = true) { typeDescriptor.loadEvaluator(); if (typeDescriptor.language == null) { typeDescriptor.language = (csharplanguage)jxshell.language.defaultLanguage.create(); } this.typeString = typeName; MethodInfo[] array = t.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod); MethodInfo[] array2 = array; for (int i = 0; i < array2.Length; i++) { MethodInfo methodInfo = array2[i]; if (!methodInfo.Name.StartsWith("get_") && !methodInfo.Name.StartsWith("set_")) { methodDescriptor methodDescriptor = null; if (methodInfo.IsGenericMethod) { string text = "generic_" + methodInfo.Name; if (!this.instanceMethods.TryGetValue(text, out methodDescriptor)) { methodDescriptor = new methodDescriptor(); methodDescriptor.isGenericMethod = true; this.instanceMethods[text] = methodDescriptor; this.methods.Add(methodDescriptor); methodDescriptor.methodOrder = this.methods.Count - 1; methodDescriptor.name = text; } } else if (!this.instanceMethods.TryGetValue(methodInfo.Name, out methodDescriptor)) { methodDescriptor = new methodDescriptor(); this.instanceMethods[methodInfo.Name] = methodDescriptor; this.methods.Add(methodDescriptor); methodDescriptor.methodOrder = this.methods.Count - 1; methodDescriptor.name = methodInfo.Name; } methodDescriptor.baseMethods.Add(methodInfo); methodDescriptor.maxParameterCount = Math.Max(methodDescriptor.maxParameterCount, methodInfo.GetParameters().Length); if (methodInfo.IsGenericMethod) { methodDescriptor.genericParameterCount = Math.Max(methodDescriptor.genericParameterCount, methodInfo.GetGenericArguments().Length); } } } PropertyInfo[] array3 = t.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy); PropertyInfo[] array4 = array3; for (int j = 0; j < array4.Length; j++) { PropertyInfo propertyInfo = array4[j]; propertyDescriptor propertyDescriptor = null; if (!this.instanceProperties.TryGetValue(propertyInfo.Name, out propertyDescriptor)) { propertyDescriptor = new propertyDescriptor(); this.instanceProperties[propertyInfo.Name] = propertyDescriptor; this.properties.Add(propertyDescriptor); propertyDescriptor.propertyOrder = this.properties.Count - 1; propertyDescriptor.name = propertyInfo.Name; } propertyDescriptor.properties.Add(propertyInfo); propertyDescriptor.maxParameterCount = Math.Max(propertyDescriptor.maxParameterCount, propertyInfo.GetIndexParameters().Length); } FieldInfo[] array5 = t.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.GetField | BindingFlags.SetField); FieldInfo[] array6 = array5; for (int k = 0; k < array6.Length; k++) { FieldInfo fieldInfo = array6[k]; fieldDescriptor fieldDescriptor = null; if (!this.instanceFields.TryGetValue(fieldInfo.Name, out fieldDescriptor)) { fieldDescriptor = new fieldDescriptor(); this.instanceFields[fieldInfo.Name] = fieldDescriptor; this.fields.Add(fieldDescriptor); fieldDescriptor.fieldOrder = this.fields.Count - 1; fieldDescriptor.name = fieldInfo.Name; } fieldDescriptor.fieldInfo = fieldInfo; } ConstructorInfo[] constructors = t.GetConstructors(); ConstructorInfo[] array7 = constructors; for (int l = 0; l < array7.Length; l++) { ConstructorInfo constructorInfo = array7[l]; methodDescriptor methodDescriptor2; if (this.constructor == null) { methodDescriptor2 = new methodDescriptor(); this.constructor = methodDescriptor2; this.methods.Add(methodDescriptor2); methodDescriptor2.name = "construct"; methodDescriptor2.methodOrder = this.methods.Count - 1; } else { methodDescriptor2 = this.constructor; } methodDescriptor2.baseMethods.Add(constructorInfo); methodDescriptor2.maxParameterCount = Math.Max(methodDescriptor2.maxParameterCount, constructorInfo.GetParameters().Length); } array = t.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod); MethodInfo[] array8 = array; for (int m = 0; m < array8.Length; m++) { MethodInfo methodInfo2 = array8[m]; if (!methodInfo2.Name.StartsWith("get_") && !methodInfo2.Name.StartsWith("set_")) { methodDescriptor methodDescriptor3 = null; if (methodInfo2.IsGenericMethod) { string text2 = "generic_" + methodInfo2.Name; if (!this.instanceMethods.TryGetValue(text2, out methodDescriptor3)) { methodDescriptor3 = new methodDescriptor(); this.staticMethods[text2] = methodDescriptor3; methodDescriptor3.isGenericMethod = true; this.methods.Add(methodDescriptor3); methodDescriptor3.methodOrder = this.methods.Count - 1; methodDescriptor3.name = text2; } } else if (!this.staticMethods.TryGetValue(methodInfo2.Name, out methodDescriptor3)) { methodDescriptor3 = new methodDescriptor(); this.staticMethods[methodInfo2.Name] = methodDescriptor3; this.methods.Add(methodDescriptor3); methodDescriptor3.name = methodInfo2.Name; methodDescriptor3.methodOrder = this.methods.Count - 1; } methodDescriptor3.baseMethods.Add(methodInfo2); methodDescriptor3.maxParameterCount = Math.Max(methodDescriptor3.maxParameterCount, methodInfo2.GetParameters().Length); if (methodInfo2.IsGenericMethod) { methodDescriptor3.genericParameterCount = Math.Max(methodDescriptor3.genericParameterCount, methodInfo2.GetGenericArguments().Length); } } } array3 = t.GetProperties(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy); PropertyInfo[] array9 = array3; for (int n = 0; n < array9.Length; n++) { PropertyInfo propertyInfo2 = array9[n]; propertyDescriptor propertyDescriptor2 = null; if (!this.staticProperties.TryGetValue(propertyInfo2.Name, out propertyDescriptor2)) { propertyDescriptor2 = new propertyDescriptor(); this.staticProperties[propertyInfo2.Name] = propertyDescriptor2; this.properties.Add(propertyDescriptor2); propertyDescriptor2.propertyOrder = this.properties.Count - 1; propertyDescriptor2.name = propertyInfo2.Name; } propertyDescriptor2.properties.Add(propertyInfo2); propertyDescriptor2.maxParameterCount = Math.Max(propertyDescriptor2.maxParameterCount, propertyInfo2.GetIndexParameters().Length); } array5 = t.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.GetField | BindingFlags.SetField); FieldInfo[] array10 = array5; for (int num = 0; num < array10.Length; num++) { FieldInfo fieldInfo2 = array10[num]; fieldDescriptor fieldDescriptor2 = null; if (!this.instanceFields.TryGetValue(fieldInfo2.Name, out fieldDescriptor2)) { fieldDescriptor2 = new fieldDescriptor(); this.staticFields[fieldInfo2.Name] = fieldDescriptor2; this.fields.Add(fieldDescriptor2); fieldDescriptor2.fieldOrder = this.fields.Count - 1; fieldDescriptor2.name = fieldInfo2.Name; } fieldDescriptor2.fieldInfo = fieldInfo2; } this.type = t; typeDescriptor.loadedTypes[t] = this; if (compile && typeDescriptor.gencompile) { this.compile(); } }
public typeDescriptor(Type t, string typeName, bool compile = true) { jxshell.dotnet4.methodDescriptor methodDescriptor; typeDescriptor.loadEvaluator(); if (typeDescriptor.language == null) { typeDescriptor.language = (csharplanguage)jxshell.language.defaultLanguage.create(); } this.typeString = typeName; MethodInfo[] methods = t.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod); for (int i = 0; i < (int)methods.Length; i++) { MethodInfo methodInfo = methods[i]; if (!methodInfo.Name.StartsWith("get_") && !methodInfo.Name.StartsWith("set_")) { jxshell.dotnet4.methodDescriptor value = null; if (methodInfo.IsGenericMethod) { string text = string.Concat("generic_", methodInfo.Name); if (!this.instanceMethods.TryGetValue(text, out value)) { value = new jxshell.dotnet4.methodDescriptor() { isGenericMethod = true }; this.instanceMethods[text] = value; this.methods.Add(value); value.methodOrder = this.methods.Count - 1; value.name = text; } } else if (!this.instanceMethods.TryGetValue(methodInfo.Name, out value)) { value = new jxshell.dotnet4.methodDescriptor(); this.instanceMethods[methodInfo.Name] = value; this.methods.Add(value); value.methodOrder = this.methods.Count - 1; value.name = methodInfo.Name; } value.baseMethods.Add(methodInfo); value.maxParameterCount = Math.Max(value.maxParameterCount, (int)methodInfo.GetParameters().Length); if (methodInfo.IsGenericMethod) { value.genericParameterCount = Math.Max(value.genericParameterCount, (int)methodInfo.GetGenericArguments().Length); } } } PropertyInfo[] properties = t.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy); for (int j = 0; j < (int)properties.Length; j++) { PropertyInfo propertyInfo = properties[j]; propertyDescriptor value2 = null; if (!this.instanceProperties.TryGetValue(propertyInfo.Name, out value2)) { value2 = new propertyDescriptor(); this.instanceProperties[propertyInfo.Name] = value2; this.properties.Add(value2); value2.propertyOrder = this.properties.Count - 1; value2.name = propertyInfo.Name; } value2.properties.Add(propertyInfo); value2.maxParameterCount = Math.Max(value2.maxParameterCount, (int)propertyInfo.GetIndexParameters().Length); } FieldInfo[] fields = t.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.GetField | BindingFlags.SetField); for (int k = 0; k < (int)fields.Length; k++) { FieldInfo fieldInfo = fields[k]; fieldDescriptor value3 = null; if (!this.instanceFields.TryGetValue(fieldInfo.Name, out value3)) { value3 = new fieldDescriptor(); this.instanceFields[fieldInfo.Name] = value3; this.fields.Add(value3); value3.fieldOrder = this.fields.Count - 1; value3.name = fieldInfo.Name; } value3.fieldInfo = fieldInfo; } ConstructorInfo[] constructors = t.GetConstructors(); for (int l = 0; l < (int)constructors.Length; l++) { ConstructorInfo constructorInfo = constructors[l]; if (this.constructor != null) { methodDescriptor = this.constructor; } else { jxshell.dotnet4.methodDescriptor _methodDescriptor = new jxshell.dotnet4.methodDescriptor(); jxshell.dotnet4.methodDescriptor _methodDescriptor1 = _methodDescriptor; this.constructor = _methodDescriptor; methodDescriptor = _methodDescriptor1; this.methods.Add(methodDescriptor); methodDescriptor.name = "construct"; methodDescriptor.methodOrder = this.methods.Count - 1; } methodDescriptor.baseMethods.Add(constructorInfo); methodDescriptor.maxParameterCount = Math.Max(methodDescriptor.maxParameterCount, (int)constructorInfo.GetParameters().Length); } MethodInfo[] methodInfoArray = t.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod); for (int m = 0; m < (int)methodInfoArray.Length; m++) { MethodInfo methodInfo2 = methodInfoArray[m]; if (!methodInfo2.Name.StartsWith("get_") && !methodInfo2.Name.StartsWith("set_")) { jxshell.dotnet4.methodDescriptor value4 = null; if (methodInfo2.IsGenericMethod) { string text2 = string.Concat("generic_", methodInfo2.Name); if (!this.instanceMethods.TryGetValue(text2, out value4)) { value4 = new jxshell.dotnet4.methodDescriptor(); this.staticMethods[text2] = value4; value4.isGenericMethod = true; this.methods.Add(value4); value4.methodOrder = this.methods.Count - 1; value4.name = text2; } } else if (!this.staticMethods.TryGetValue(methodInfo2.Name, out value4)) { value4 = new jxshell.dotnet4.methodDescriptor(); this.staticMethods[methodInfo2.Name] = value4; this.methods.Add(value4); value4.name = methodInfo2.Name; value4.methodOrder = this.methods.Count - 1; } value4.baseMethods.Add(methodInfo2); value4.maxParameterCount = Math.Max(value4.maxParameterCount, (int)methodInfo2.GetParameters().Length); if (methodInfo2.IsGenericMethod) { value4.genericParameterCount = Math.Max(value4.genericParameterCount, (int)methodInfo2.GetGenericArguments().Length); } } } PropertyInfo[] propertyInfoArray = t.GetProperties(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy); for (int n = 0; n < (int)propertyInfoArray.Length; n++) { PropertyInfo propertyInfo2 = propertyInfoArray[n]; propertyDescriptor value5 = null; if (!this.staticProperties.TryGetValue(propertyInfo2.Name, out value5)) { value5 = new propertyDescriptor(); this.staticProperties[propertyInfo2.Name] = value5; this.properties.Add(value5); value5.propertyOrder = this.properties.Count - 1; value5.name = propertyInfo2.Name; } value5.properties.Add(propertyInfo2); value5.maxParameterCount = Math.Max(value5.maxParameterCount, (int)propertyInfo2.GetIndexParameters().Length); } FieldInfo[] fieldInfoArray = t.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.GetField | BindingFlags.SetField); for (int o = 0; o < (int)fieldInfoArray.Length; o++) { FieldInfo fieldInfo2 = fieldInfoArray[o]; fieldDescriptor value6 = null; if (!this.instanceFields.TryGetValue(fieldInfo2.Name, out value6)) { value6 = new fieldDescriptor(); this.staticFields[fieldInfo2.Name] = value6; this.fields.Add(value6); value6.fieldOrder = this.fields.Count - 1; value6.name = fieldInfo2.Name; } value6.fieldInfo = fieldInfo2; } this.type = t; typeDescriptor.loadedTypes[t] = this; if (compile && typeDescriptor.gencompile) { this.compile(); } }
internal static void _execute(Command cmd) { try { //File.WriteAllText("/Users/james/commands.log", Newtonsoft.Json.JsonConvert.SerializeObject(cmd)); object[] args; if (cmd.arguments != null) { args = new object[cmd.arguments.Count]; for (int i = 0; i < cmd.arguments.Count; i++) { args[i] = cmd.arguments[i].getValue(); } } else { args = new object[0]; } bool emp = false; if (cmd.command == "assembly.add") { for (int i = 0; i < cmd.arguments.Count; i++) { Manager.lastManager.loadAssemblyPartialName(cmd.arguments[i].getValue().ToString()); } emp = true; } else if (cmd.command == "assembly.addfile") { for (int i = 0; i < cmd.arguments.Count; i++) { Manager.lastManager.loadAssemblyFile(cmd.arguments[i].getValue().ToString()); } emp = true; } else if (cmd.command == "remove") { if (cmd.objectid > 0) { Objects.remove(cmd.objectid); } emp = true; } else if (cmd.command == "compile") { string code = cmd.arguments[0].getValue().ToString(); csharplanguage lang = (csharplanguage)language.languages["c#"].create(); lang.compileString(code, ""); Assembly a = lang.getCompiledAssembly(); if (a != null) { Manager.lastManager.loadAssembly(a); } emp = true; } else if (cmd.command == "loadmembers") { //string code = cmd.typename; Type ty = Manager.lastManager.getTypeOrGenericType(cmd.typename); typeDescriptor t2 = typeDescriptor.loadFromType(ty, "", false); TypeLoader.TypeResponse tr = TypeLoader.loadMembers(t2); cmd.command = "get"; Response r = new Response(cmd, tr, null); CommandLine.write(r); } else if (cmd.objectid > 0) { object obj = Objects.getbyid(cmd.objectid); if (obj == null) { throw new NullReferenceException("El objeto ha sido liberado de memoria o el id no es válido"); } object result = null; if (cmd.getproperty) { result = TypeLoader.getProperty(cmd, ref args, obj); } else if (cmd.getfield) { result = TypeLoader.getField(cmd, obj); } else if (cmd.method) { result = TypeLoader.invokeMethod(cmd, ref args, obj); } else if (cmd.setproperty) { TypeLoader.setProperty(cmd, ref args, obj, cmd.value.getValue()); } else if (cmd.setfield) { TypeLoader.setField(cmd, obj, cmd.value.getValue()); } Response r = new Response(cmd, result, null); CommandLine.write(r); } else { object result = null; if (cmd.getproperty) { result = TypeLoader.getProperty(cmd, ref args, null); } else if (cmd.getfield) { result = TypeLoader.getField(cmd, null); } else if (cmd.method) { result = TypeLoader.invokeMethod(cmd, ref args, null); } else if (cmd.setproperty) { TypeLoader.setProperty(cmd, ref args, null, cmd.value.getValue()); } else if (cmd.setfield) { TypeLoader.setField(cmd, null, cmd.value.getValue()); } Response r = new Response(cmd, result, null); CommandLine.write(r); } if (emp) { CommandLine.write(new Response { isnull = true, commandid = cmd.commandid }); } } catch (Exception e) { if (e.InnerException != null) { throw e.InnerException; } if (e is KeyNotFoundException) { throw new MissingMemberException("El método o propiedad no existe"); } throw; } }
public typeDescriptor(Type t, string typeName, bool compile = true) { methodDescriptor count; typeDescriptor.loadEvaluator(); if (typeDescriptor.language == null) { typeDescriptor.language = (csharplanguage)jxshell.language.defaultLanguage.create(); } this.typeString = typeName; MethodInfo[] methods = t.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod); for (int i = 0; i < (int)methods.Length; i++) { MethodInfo methodInfo = methods[i]; if ((methodInfo.Name.StartsWith("get_") ? false : !methodInfo.Name.StartsWith("set_"))) { methodDescriptor _methodDescriptor = null; if (methodInfo.IsGenericMethod) { string str = string.Concat("generic_", methodInfo.Name); if (!this.instanceMethods.TryGetValue(str, out _methodDescriptor)) { _methodDescriptor = new methodDescriptor() { isGenericMethod = true }; this.instanceMethods[str] = _methodDescriptor; this.methods.Add(_methodDescriptor); _methodDescriptor.methodOrder = this.methods.Count - 1; _methodDescriptor.name = str; } } else if (!this.instanceMethods.TryGetValue(methodInfo.Name, out _methodDescriptor)) { _methodDescriptor = new methodDescriptor(); this.instanceMethods[methodInfo.Name] = _methodDescriptor; this.methods.Add(_methodDescriptor); _methodDescriptor.methodOrder = this.methods.Count - 1; _methodDescriptor.name = methodInfo.Name; } _methodDescriptor.baseMethods.Add(methodInfo); _methodDescriptor.maxParameterCount = Math.Max(_methodDescriptor.maxParameterCount, (int)methodInfo.GetParameters().Length); if (methodInfo.IsGenericMethod) { _methodDescriptor.genericParameterCount = Math.Max(_methodDescriptor.genericParameterCount, (int)methodInfo.GetGenericArguments().Length); } } } PropertyInfo[] properties = t.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy); for (int j = 0; j < (int)properties.Length; j++) { PropertyInfo propertyInfo = properties[j]; propertyDescriptor _propertyDescriptor = null; if (!this.instanceProperties.TryGetValue(propertyInfo.Name, out _propertyDescriptor)) { _propertyDescriptor = new propertyDescriptor(); this.instanceProperties[propertyInfo.Name] = _propertyDescriptor; this.properties.Add(_propertyDescriptor); _propertyDescriptor.propertyOrder = this.properties.Count - 1; _propertyDescriptor.name = propertyInfo.Name; } _propertyDescriptor.properties.Add(propertyInfo); _propertyDescriptor.maxParameterCount = Math.Max(_propertyDescriptor.maxParameterCount, (int)propertyInfo.GetIndexParameters().Length); } FieldInfo[] fields = t.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.GetField | BindingFlags.SetField); for (int k = 0; k < (int)fields.Length; k++) { FieldInfo fieldInfo = fields[k]; fieldDescriptor _fieldDescriptor = null; if (!this.instanceFields.TryGetValue(fieldInfo.Name, out _fieldDescriptor)) { _fieldDescriptor = new fieldDescriptor(); this.instanceFields[fieldInfo.Name] = _fieldDescriptor; this.fields.Add(_fieldDescriptor); _fieldDescriptor.fieldOrder = this.fields.Count - 1; _fieldDescriptor.name = fieldInfo.Name; } _fieldDescriptor.fieldInfo = fieldInfo; } ConstructorInfo[] constructors = t.GetConstructors(); for (int l = 0; l < (int)constructors.Length; l++) { ConstructorInfo constructorInfo = constructors[l]; if (this.constructor == null) { methodDescriptor _methodDescriptor1 = new methodDescriptor(); methodDescriptor _methodDescriptor2 = _methodDescriptor1; this.constructor = _methodDescriptor1; count = _methodDescriptor2; this.methods.Add(count); count.name = "construct"; count.methodOrder = this.methods.Count - 1; } else { count = this.constructor; } count.baseMethods.Add(constructorInfo); count.maxParameterCount = Math.Max(count.maxParameterCount, (int)constructorInfo.GetParameters().Length); } MethodInfo[] methodInfoArray = t.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.InvokeMethod); for (int m = 0; m < (int)methodInfoArray.Length; m++) { MethodInfo methodInfo1 = methodInfoArray[m]; if ((methodInfo1.Name.StartsWith("get_") ? false : !methodInfo1.Name.StartsWith("set_"))) { methodDescriptor name = null; if (methodInfo1.IsGenericMethod) { string str1 = string.Concat("generic_", methodInfo1.Name); if (!this.instanceMethods.TryGetValue(str1, out name)) { name = new methodDescriptor(); this.staticMethods[str1] = name; name.isGenericMethod = true; this.methods.Add(name); name.methodOrder = this.methods.Count - 1; name.name = str1; } } else if (!this.staticMethods.TryGetValue(methodInfo1.Name, out name)) { name = new methodDescriptor(); this.staticMethods[methodInfo1.Name] = name; this.methods.Add(name); name.name = methodInfo1.Name; name.methodOrder = this.methods.Count - 1; } name.baseMethods.Add(methodInfo1); name.maxParameterCount = Math.Max(name.maxParameterCount, (int)methodInfo1.GetParameters().Length); if (methodInfo1.IsGenericMethod) { name.genericParameterCount = Math.Max(name.genericParameterCount, (int)methodInfo1.GetGenericArguments().Length); } } } PropertyInfo[] propertyInfoArray = t.GetProperties(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy); for (int n = 0; n < (int)propertyInfoArray.Length; n++) { PropertyInfo propertyInfo1 = propertyInfoArray[n]; propertyDescriptor _propertyDescriptor1 = null; if (!this.staticProperties.TryGetValue(propertyInfo1.Name, out _propertyDescriptor1)) { _propertyDescriptor1 = new propertyDescriptor(); this.staticProperties[propertyInfo1.Name] = _propertyDescriptor1; this.properties.Add(_propertyDescriptor1); _propertyDescriptor1.propertyOrder = this.properties.Count - 1; _propertyDescriptor1.name = propertyInfo1.Name; } _propertyDescriptor1.properties.Add(propertyInfo1); _propertyDescriptor1.maxParameterCount = Math.Max(_propertyDescriptor1.maxParameterCount, (int)propertyInfo1.GetIndexParameters().Length); } FieldInfo[] fieldInfoArray = t.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.FlattenHierarchy | BindingFlags.GetField | BindingFlags.SetField); for (int o = 0; o < (int)fieldInfoArray.Length; o++) { FieldInfo fieldInfo1 = fieldInfoArray[o]; fieldDescriptor _fieldDescriptor1 = null; if (!this.instanceFields.TryGetValue(fieldInfo1.Name, out _fieldDescriptor1)) { _fieldDescriptor1 = new fieldDescriptor(); this.staticFields[fieldInfo1.Name] = _fieldDescriptor1; this.fields.Add(_fieldDescriptor1); _fieldDescriptor1.fieldOrder = this.fields.Count - 1; _fieldDescriptor1.name = fieldInfo1.Name; } _fieldDescriptor1.fieldInfo = fieldInfo1; } this.type = t; typeDescriptor.loadedTypes[t] = this; if ((!compile ? false : typeDescriptor.gencompile)) { this.compile(); } }