public Maybe<ITransactionOptions> AsTransactional(MethodInfo target) { Contract.Requires(target != null); Contract.Ensures(Contract.Result<Maybe<TransactionAttribute>>() != null); return _TxMethodsHackMap.ContainsKey(target.ToString()) ? Maybe.Some<ITransactionOptions>(_TxMethodsHackMap[target.ToString()]) : Maybe.None<ITransactionOptions>(); }
private static IntPtr MethodInfoToFtnptr (MethodInfo method) { if (module_builder.Assembly.GetType ("BridgeHelpers" + method.ToString ()) != null) return (IntPtr) module_builder.Assembly.GetType ("BridgeHelpers" + method.ToString ()).InvokeMember ("InternalMethodInfoToFtnPtr", BindingFlags.Static | BindingFlags.InvokeMethod | BindingFlags.Public, null, null, new object[] { }); TypeBuilder ftn_converter_builder = module_builder.DefineType ("BridgeHelpers" + method.ToString (), TypeAttributes.Public); MethodBuilder ftn_method = ftn_converter_builder.DefineMethod ("InternalMethodInfoToFtnPtr", MethodAttributes.Public | MethodAttributes.Static, typeof (IntPtr), new Type[] { }); ILGenerator il_generator = ftn_method.GetILGenerator (); il_generator.Emit (OpCodes.Ldftn, method); il_generator.Emit (OpCodes.Ret); Type ftn_converter = ftn_converter_builder.CreateType (); return (IntPtr) ftn_converter.InvokeMember ("InternalMethodInfoToFtnPtr", BindingFlags.Static | BindingFlags.InvokeMethod | BindingFlags.Public, null, null, new object[] { }); }
internal static WebMethodAttribute GetAttribute(MethodInfo implementation, MethodInfo declaration) { WebMethodAttribute attribute = null; WebMethodAttribute attribute2 = null; object[] customAttributes; if (declaration != null) { customAttributes = declaration.GetCustomAttributes(typeof(WebMethodAttribute), false); if (customAttributes.Length > 0) { attribute = (WebMethodAttribute) customAttributes[0]; } } customAttributes = implementation.GetCustomAttributes(typeof(WebMethodAttribute), false); if (customAttributes.Length > 0) { attribute2 = (WebMethodAttribute) customAttributes[0]; } if (attribute == null) { return attribute2; } if (attribute2 == null) { return attribute; } if (attribute2.MessageNameSpecified) { throw new InvalidOperationException(Res.GetString("ContractOverride", new object[] { implementation.Name, implementation.DeclaringType.FullName, declaration.DeclaringType.FullName, declaration.ToString(), "WebMethod.MessageName" })); } return new WebMethodAttribute(attribute2.EnableSessionSpecified ? attribute2.EnableSession : attribute.EnableSession) { TransactionOption = attribute2.TransactionOptionSpecified ? attribute2.TransactionOption : attribute.TransactionOption, CacheDuration = attribute2.CacheDurationSpecified ? attribute2.CacheDuration : attribute.CacheDuration, BufferResponse = attribute2.BufferResponseSpecified ? attribute2.BufferResponse : attribute.BufferResponse, Description = attribute2.DescriptionSpecified ? attribute2.Description : attribute.Description }; }
public IHqlGeneratorForMethod GetMethodGenerator(MethodInfo method) { IHqlGeneratorForMethod methodGenerator; if (method.IsGenericMethod) { method = method.GetGenericMethodDefinition(); } if (_registeredMethods.TryGetValue(method, out methodGenerator)) { return methodGenerator; } // No method generator registered. Look to see if it's a standard LinqExtensionMethod var attr = method.GetCustomAttributes(typeof (LinqExtensionMethodAttribute), false); if (attr.Length == 1) { // It is // TODO - cache this? Is it worth it? return new HqlGeneratorForExtensionMethod((LinqExtensionMethodAttribute) attr[0], method); } // Not that either. Let's query each type generator to see if it can handle it foreach (var typeGenerator in _typeGenerators) { if (typeGenerator.SupportsMethod(method)) { return typeGenerator.GetMethodGenerator(method); } } throw new NotSupportedException(method.ToString()); }
public MethodNode(object parentObj, MethodInfo m) : base(null, NodeTypes.Method, m.ToString()) { parentObject = parentObj; method = m; CanInvoke = true; }
protected Command(object target, MethodInfo mi) : base(target, mi) { ParameterInfo[] paramList = mi.GetParameters(); _names = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase); List<Argument> tempList = new List<Argument>(); foreach (ParameterInfo pi in paramList) { Argument arg = new Argument(target, pi); foreach(string name in arg.AllNames) _names.Add(name, tempList.Count); tempList.Add(arg); } _arguments = tempList.ToArray(); if (base.Description == mi.ToString()) {//if no description provided, let's build a better one StringBuilder sb = new StringBuilder(); sb.AppendFormat("{0} ", base.DisplayName); foreach(Argument a in tempList) if(a.Visible) sb.AppendFormat("{0} ", a.FormatSyntax(a.DisplayName)); _description = sb.ToString(0, sb.Length - 1); } }
public MethodInfo(System.Reflection.MethodInfo mi) { name = mi.Name; // get acces modifires modificators = GetModificators(mi.GetType()) + mi.ToString(); if (mi.IsAbstract && !mi.DeclaringType.IsInterface) { modificators += "abstract "; } if (mi.GetCustomAttribute(typeof(AsyncStateMachineAttribute)) != null) { modificators += "async "; } if ((mi.MethodImplementationFlags & MethodImplAttributes.InternalCall) != 0) { modificators += "extern "; } if (!mi.Equals(mi.GetBaseDefinition())) { modificators += "overriden "; } if (mi.IsVirtual && mi.IsFinal) { modificators += "sealed "; } if (mi.IsStatic) { modificators += "static "; } if (mi.IsVirtual && !mi.IsFinal && mi.Equals(mi.GetBaseDefinition()) && !mi.DeclaringType.IsInterface) { modificators += "virtual "; } }
public static void executeXRuleMethod(MethodInfo methodToExecute, Action<bool,object> executionResult) { if (methodToExecute == null) { executionResult(false,null); } else try { DI.log.info("executing method: {0}", methodToExecute.Name); // create method's type using default constructor var liveObject = DI.reflection.createObjectUsingDefaultConstructor(methodToExecute.DeclaringType); // and execute the method var returnData = methodToExecute.Invoke(liveObject, new object[] { }); // don't use the DI.reflection methods since we want the exceptions to be thrown //DI.reflection.invoke(liveObject, methodInfo, new object[] {}); executionResult(true, returnData); } catch (Exception ex) { DI.log.error("in UnitTestSupport.executeXRuleMethod: {0} threw error: {1} ", methodToExecute.ToString(), ex.Message); if (ex.InnerException != null) { var innerExceptionMessage = ex.InnerException.Message; DI.log.error(" InnerException value: {0}", innerExceptionMessage); executionResult(false, innerExceptionMessage); } else executionResult(false, null); } }
public void WriteMethod(System.Type type, bool isStatic, System.Reflection.MethodInfo method) { WriteTypeName(type); Console.WriteLine("," + method.Name + ",Public Method" + "," + // property scope column ",\"" + (isStatic?"static ":"") + method.ToString() + "\""); }
public void EmitCall(OpCode opCode, MethodInfo mi) { ProcessCommand( opCode, (mi.GetParameters().Length + 1) * -1 + (mi.ReturnType == typeof(void) ? 0 : 1), mi.ToString() ); ilGenerator.EmitCall(opCode, mi, null); }
public void WriteOperator(System.Type type, System.Reflection.MethodInfo method) { string value; bool found = _operators.TryGetValue(method.Name, out value); WriteTypeName(type); Console.WriteLine("," + (found?value:method.Name) + ",Operator" + "," + // property scope column ",\"" + method.ToString() + "\""); }
public IHqlGeneratorForMethod GetMethodGenerator(MethodInfo method) { IHqlGeneratorForMethod methodGenerator; if (!TryGetMethodGenerator(method, out methodGenerator)) { throw new NotSupportedException(method.ToString()); } return methodGenerator; }
private MethodInfo GetParallelMethod(MethodInfo forkMethod) { MethodInfo result = null; MethodInfo[] methods = source.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); foreach (MethodInfo method in methods) if (IsParallel(method) && SignatureMatch(forkMethod, method)) { if (result == null) result = method; else throw new InvalidMethodException(source.Name, forkMethod.ToString(), "There is more than one parallel method which has a nonchannel parameter signature that matches this [Fork] method."); } if (result == null) throw new InvalidMethodException(source.Name, forkMethod.ToString(), "There is no parallel method which has a nonchannel parameter signature that matches this [Fork] method."); return result; }
public static MethodDefinition getMethodDefinitionFromMethodInfo(MethodInfo methodInfo, Mono.Cecil.AssemblyDefinition assemblyDefinition) { foreach (var methodDefinition in CecilUtils.getMethods(assemblyDefinition)) { var functionSignature1 = new FilteredSignature(methodInfo); var functionSignature2 = new FilteredSignature(methodDefinition.ToString()); if (functionSignature1.sSignature == functionSignature2.sSignature) return methodDefinition; if (functionSignature1.sFunctionName == functionSignature2.sFunctionName) { } } PublicDI.log.error("in getMethodDefinitionFromMethodInfo, could not map MethodInfo: {0}", methodInfo.ToString()); return null; }
public static void Calculate(ShowResult showResult, int a, int b) { if (a < 0 || b < 0) { Console.WriteLine("参数有误"); } else { System.Reflection.MethodInfo methodInfo = RuntimeReflectionExtensions.GetMethodInfo(showResult); Console.WriteLine("在这里写入一条日志" + methodInfo.ToString()); Console.WriteLine(showResult?.Invoke(a, b)); //Console.WriteLine(showResult(a, b)); } }
public object GetRealObject(StreamingContext context) { switch (_memberType) { case MemberTypes.Constructor: ConstructorInfo [] ctors; ctors = _reflectedType.GetConstructors(DefaultBinding); for (int i = 0; i < ctors.Length; i++) { if (ctors[i].ToString().Equals(_memberSignature)) { return(ctors[i]); } } throw new SerializationException(String.Format("Could not find constructor '{0}' in type '{1}'", _memberSignature, _reflectedType)); case MemberTypes.Method: MethodInfo [] methods; methods = _reflectedType.GetMethods(DefaultBinding); for (int i = 0; i < methods.Length; i++) { if ((methods[i]).ToString().Equals(_memberSignature)) { return(methods[i]); } } #if NET_2_0 else if (_genericArguments != null && methods[i].IsGenericMethod && methods[i].GetGenericArguments().Length == _genericArguments.Length) { MethodInfo mi = methods[i].MakeGenericMethod(_genericArguments); if (mi.ToString() == _memberSignature) { return(mi); } } #endif throw new SerializationException(String.Format("Could not find method '{0}' in type '{1}'", _memberSignature, _reflectedType));
// Methods public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo) { #region Contracts if (controllerContext == null) throw new ArgumentNullException(); if (methodInfo == null) throw new ArgumentNullException(); #endregion // ParameterInfoArray var parameterInfoArray = ParameterInfoFactory.Current.GetAll(controllerContext.Controller.GetType(), methodInfo); if (parameterInfoArray == null) throw new InvalidOperationException(); // Current Overload Action Matching if (this.IsOverloadMatched(controllerContext, parameterInfoArray) == false) { return false; } // Other MethodInfoArray var otherMethodInfoArray = MethodInfoFactory.Current.GetAll(controllerContext.Controller.GetType()); if (otherMethodInfoArray == null) throw new InvalidOperationException(); // Other Overload Action Matching foreach (var otherMethodInfo in otherMethodInfoArray) { // MethodInfo if (otherMethodInfo.Name != methodInfo.Name) continue; if (otherMethodInfo.ToString() == methodInfo.ToString()) continue; if (otherMethodInfo.GetCustomAttribute<OverloadAttribute>() == null) continue; // ParameterInfoArray var otherParameterInfoArray = ParameterInfoFactory.Current.GetAll(controllerContext.Controller.GetType(), otherMethodInfo); if (otherParameterInfoArray == null) throw new InvalidOperationException(); if (otherParameterInfoArray.Length < parameterInfoArray.Length) continue; // IsOverloadMatched if (this.IsOverloadMatched(controllerContext, otherParameterInfoArray) == true) return false; } // Return return true; }
public override DynamicMethodProxyHandler GetMethodDelegate( Module targetModule, MethodInfo genericMethodInfo, params Type[] genericParameterTypes) { #region Construct cache key if (targetModule == null) { throw new ArgumentNullException("targetModule"); } string key = targetModule.FullyQualifiedName + "|" + genericMethodInfo.DeclaringType.ToString() + "|" + genericMethodInfo.ToString(); if (genericParameterTypes != null) { for (int i = 0; i < genericParameterTypes.Length; ++i) { key += "|" + genericParameterTypes[i].ToString(); } } #endregion DynamicMethodProxyHandler dmd; lock (cache2) { if (cache2.ContainsKey(key)) { dmd = cache2[key]; } else { dmd = DoGetMethodDelegate(targetModule, genericMethodInfo, genericParameterTypes); cache2.Add(key, dmd); } } return dmd; }
public static MethodInvokerBase GetMethodInvoker(object targetObject, MethodInfo mi) { var typeName = "EmitMapper.MethodCaller_" + mi.ToString(); Type callerType = _typesCache.Get<Type>( typeName, () => { if (mi.ReturnType == typeof(void)) { return BuildActionCallerType(typeName, mi); } else { return BuildFuncCallerType(typeName, mi); } } ); MethodInvokerBase result = (MethodInvokerBase)Activator.CreateInstance(callerType); result.targetObject = targetObject; return result; }
public static ProductionRule GenerateRule(MethodInfo method) { ProductionAttribute production = (ProductionAttribute)Attribute.GetCustomAttribute(method, typeof(ProductionAttribute), false); if (production == null) { return null; } Type[] newLeft, left, strict, right, newRight; production.GetTypes(method, out newLeft, out left, out strict, out right, out newRight); var ignoreList = IgnoreAttribute.GetIgnoredTypes(method); foreach(var p in method.GetParameters()) { if (ignoreList.Contains(p.ParameterType)) { throw new InvalidOperationException(string.Format( "ProductionRule: Ignored type is production function parameters list (class: {0}, method: {1}).", method.DeclaringType.Name, method.ToString())); } } Array.Reverse(newLeft); Array.Reverse(left); return new ProductionRule() { Method = method, NewLeft = newLeft, Left = left, Strict = strict, Right = right, NewRight = newRight, IgnoreList = ignoreList }; }
public bool OkToUse(MethodInfo m, out string message) { if (m == null) throw new ArgumentNullException("m"); string toCheckStr = m.DeclaringType.ToString() + "." + m.ToString(); //[email protected] return OkToUseInternal(toCheckStr + "/" + m.ReturnType.ToString(), this.require_members, this.forbid_members, out message); //[email protected] //return OkToUseInternal(m.ToString() + "/" + m.ReturnType.ToString(), this.require_members, this.forbid_members, out message); //[email protected] }
/// <summary> /// Invokes the event handler identified by the given method on the given instance. /// </summary> /// <param name="instance">The instance to invoke the event handler on.</param> /// <param name="method">The method identifying the event handler to invoke.</param> private void InvokeEventHandler(object instance, MethodInfo method) { ParameterInfo[] args = method.GetParameters(); switch (args.Length) { case 2: method.Invoke(instance, new object[] { this, new EventArgs() }); break; case 1: method.Invoke(instance, new object[] { this }); break; case 0: method.Invoke(instance, null); break; default: throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "The specified method was expected to have 0, 1, or 2 parameters: {0}", method.ToString())); } }
public virtual object GetRealObject(StreamingContext context) { if (this.m_memberName == null || this.m_reflectedType == null || this.m_memberType == (MemberTypes)0) { throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState")); } BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.OptionalParamBinding; MemberTypes memberType = this.m_memberType; switch (memberType) { case MemberTypes.Constructor: { if (this.m_signature == null) { throw new SerializationException(Environment.GetResourceString("Serialization_NullSignature")); } ConstructorInfo[] array = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Constructor, bindingAttr) as ConstructorInfo[]; if (array.Length == 1) { return(array[0]); } if (array.Length > 1) { for (int i = 0; i < array.Length; i++) { if (this.m_signature2 != null) { if (((RuntimeConstructorInfo)array[i]).SerializationToString().Equals(this.m_signature2)) { return(array[i]); } } else if (array[i].ToString().Equals(this.m_signature)) { return(array[i]); } } } throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } case MemberTypes.Event: { EventInfo[] array2 = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Event, bindingAttr) as EventInfo[]; if (array2.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } return(array2[0]); } case MemberTypes.Constructor | MemberTypes.Event: break; case MemberTypes.Field: { FieldInfo[] array3 = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Field, bindingAttr) as FieldInfo[]; if (array3.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } return(array3[0]); } default: if (memberType != MemberTypes.Method) { if (memberType == MemberTypes.Property) { PropertyInfo[] array4 = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Property, bindingAttr) as PropertyInfo[]; if (array4.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } if (array4.Length == 1) { return(array4[0]); } if (array4.Length > 1) { for (int j = 0; j < array4.Length; j++) { if (this.m_signature2 != null) { if (((RuntimePropertyInfo)array4[j]).SerializationToString().Equals(this.m_signature2)) { return(array4[j]); } } else if (array4[j].ToString().Equals(this.m_signature)) { return(array4[j]); } } } throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } } else { MethodInfo methodInfo = null; if (this.m_signature == null) { throw new SerializationException(Environment.GetResourceString("Serialization_NullSignature")); } Type[] array5 = this.m_info.GetValueNoThrow("GenericArguments", typeof(Type[])) as Type[]; MethodInfo[] array6 = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Method, bindingAttr) as MethodInfo[]; if (array6.Length == 1) { methodInfo = array6[0]; } else if (array6.Length > 1) { for (int k = 0; k < array6.Length; k++) { if (this.m_signature2 != null) { if (((RuntimeMethodInfo)array6[k]).SerializationToString().Equals(this.m_signature2)) { methodInfo = array6[k]; break; } } else if (array6[k].ToString().Equals(this.m_signature)) { methodInfo = array6[k]; break; } if (array5 != null && array6[k].IsGenericMethod && array6[k].GetGenericArguments().Length == array5.Length) { MethodInfo methodInfo2 = array6[k].MakeGenericMethod(array5); if (this.m_signature2 != null) { if (((RuntimeMethodInfo)methodInfo2).SerializationToString().Equals(this.m_signature2)) { methodInfo = methodInfo2; break; } } else if (methodInfo2.ToString().Equals(this.m_signature)) { methodInfo = methodInfo2; break; } } } } if (methodInfo == null) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } if (!methodInfo.IsGenericMethodDefinition) { return(methodInfo); } if (array5 == null) { return(methodInfo); } if (array5[0] == null) { return(null); } return(methodInfo.MakeGenericMethod(array5)); } break; } throw new ArgumentException(Environment.GetResourceString("Serialization_MemberTypeNotRecognized")); }
public virtual object GetRealObject(StreamingContext context) { MethodInfo info; Type[] valueNoThrow; if (((this.m_memberName == null) || (this.m_reflectedType == null)) || (this.m_memberType == 0)) { throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState")); } BindingFlags bindingAttr = BindingFlags.OptionalParamBinding | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance; switch (this.m_memberType) { case MemberTypes.Constructor: { if (this.m_signature == null) { throw new SerializationException(Environment.GetResourceString("Serialization_NullSignature")); } ConstructorInfo[] infoArray4 = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Constructor, bindingAttr) as ConstructorInfo[]; if (infoArray4.Length == 1) { return(infoArray4[0]); } if (infoArray4.Length > 1) { for (int i = 0; i < infoArray4.Length; i++) { if (infoArray4[i].ToString().Equals(this.m_signature)) { return(infoArray4[i]); } } } throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } case MemberTypes.Event: { EventInfo[] infoArray2 = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Event, bindingAttr) as EventInfo[]; if (infoArray2.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } return(infoArray2[0]); } case MemberTypes.Field: { FieldInfo[] infoArray = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Field, bindingAttr) as FieldInfo[]; if (infoArray.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } return(infoArray[0]); } case MemberTypes.Method: { info = null; if (this.m_signature == null) { throw new SerializationException(Environment.GetResourceString("Serialization_NullSignature")); } valueNoThrow = this.m_info.GetValueNoThrow("GenericArguments", typeof(Type[])) as Type[]; MethodInfo[] infoArray5 = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Method, bindingAttr) as MethodInfo[]; if (infoArray5.Length == 1) { info = infoArray5[0]; } else if (infoArray5.Length > 1) { for (int j = 0; j < infoArray5.Length; j++) { if (infoArray5[j].ToString().Equals(this.m_signature)) { info = infoArray5[j]; break; } if (((valueNoThrow != null) && infoArray5[j].IsGenericMethod) && (infoArray5[j].GetGenericArguments().Length == valueNoThrow.Length)) { MethodInfo info2 = infoArray5[j].MakeGenericMethod(valueNoThrow); if (info2.ToString().Equals(this.m_signature)) { info = info2; break; } } } } break; } case MemberTypes.Property: { PropertyInfo[] infoArray3 = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Property, bindingAttr) as PropertyInfo[]; if (infoArray3.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } if (infoArray3.Length == 1) { return(infoArray3[0]); } if (infoArray3.Length > 1) { for (int k = 0; k < infoArray3.Length; k++) { if (infoArray3[k].ToString().Equals(this.m_signature)) { return(infoArray3[k]); } } } throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } default: throw new ArgumentException(Environment.GetResourceString("Serialization_MemberTypeNotRecognized")); } if (info == null) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", new object[] { this.m_memberName })); } if (!info.IsGenericMethodDefinition) { return(info); } if (valueNoThrow == null) { return(info); } if (valueNoThrow[0] == null) { return(null); } return(info.MakeGenericMethod(valueNoThrow)); }
public bool VerifyMatchedAction(MethodInfo method) { return _actionMappings.Any(item => ((ReflectedHttpActionDescriptor)item).MethodInfo.ToString() == method.ToString()); }
internal void Call(MethodInfo methodInfo) { if (methodInfo.IsVirtual && !methodInfo.DeclaringType.GetTypeInfo().IsValueType) { if (_codeGenTrace != CodeGenTrace.None) EmitSourceInstruction("Callvirt " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString()); _ilGen.Emit(OpCodes.Callvirt, methodInfo); } else if (methodInfo.IsStatic) { if (_codeGenTrace != CodeGenTrace.None) EmitSourceInstruction("Static Call " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString()); _ilGen.Emit(OpCodes.Call, methodInfo); } else { if (_codeGenTrace != CodeGenTrace.None) EmitSourceInstruction("Call " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString()); _ilGen.Emit(OpCodes.Call, methodInfo); } }
public Form2(Assembly asm, MethodInfo meth, List<Memory> mem) { InitializeComponent(); assembly = asm; method = meth; memory = mem; label6.Text = "Method: " + meth.ToString(); // Param combo box int count = 0; foreach (ParameterInfo param in method.GetParameters()) { comboBox1.Items.Add("#" + (count + 1).ToString() + " " + param.ParameterType.ToString().Replace("System.", "")); ListViewItem item = new ListViewItem("#" + (count + 1).ToString()); item.SubItems.Add(param.ParameterType.ToString().Replace("System.", "")); item.SubItems.Add(""); listView1.Items.Add (item); count++; parameters.Add(new Parameter()); parameters[parameters.Count - 1].parameterType = param.ParameterType; } if (count == 0) { comboBox1.Items.Add("None"); comboBox1.SelectedIndex = 0; comboBox1.Enabled = false; comboBox3.Enabled = false; button5.Enabled = false; button6.Enabled = false; } else { comboBox1.SelectedIndex = 0; } // Fill store box for (int i = 0; i < memory.Count; i++) { // No result storing on void if (method.ReturnType != typeof(void)) { comboBox2.Items.Add("Memory #" + (i + 1)); if ((memory[i].full == false) && (comboBox2.SelectedIndex < 0)) { comboBox2.SelectedIndex = i; storeTo = i; } } } if (method.ReturnType != typeof(void)) { comboBox2.Items.Add("None"); } }
public static bool IsSupportedOnCurrentRuntime(MethodInfo mi) { SupportedRuntimeAttribute[] supportedRuntimes = (SupportedRuntimeAttribute[])mi.GetCustomAttributes(typeof(SupportedRuntimeAttribute), true); NotSupportedRuntimeAttribute[] notSupportedRuntimes = (NotSupportedRuntimeAttribute[])mi.GetCustomAttributes(typeof(NotSupportedRuntimeAttribute), true); // no attributes defined - we default to Yes. if (supportedRuntimes.Length + notSupportedRuntimes.Length == 0) return true; bool supported = false; if (supportedRuntimes.Length == 0) supported = true; foreach (SupportedRuntimeAttribute sr in supportedRuntimes) { if (RuntimeMatches(sr)) { supported = true; break; } } if (supported) { foreach (NotSupportedRuntimeAttribute nsr in notSupportedRuntimes) { if (RuntimeMatches(nsr)) { supported = false; break; } } } if (!supported) InternalLogger.Debug("{0} is not supported on current runtime.", mi.ToString()); return supported; }
public static DynamicMethodDelegate GetDynamicMethodDelegate(MethodInfo genericMethodInfo, params Type[] genericParameterTypes) { #region 检查参数的有效性 if (genericMethodInfo == null) { throw new ArgumentNullException("需要被调用的方法的genericMethodInfo不能为空!"); } if (genericParameterTypes != null) { if (genericParameterTypes.Length != genericMethodInfo.GetGenericArguments().Length) { throw new ArgumentException("genericMethodInfo和泛型参数类型的数量不一致!"); } } else { if (genericMethodInfo.GetGenericArguments().Length > 0) { throw new ArgumentException("没有为genericMethodInfo指定泛型参数类型!"); } } #endregion #region 构造用于缓存的key string key = genericMethodInfo.DeclaringType.ToString() + "|" + genericMethodInfo.ToString(); if (genericParameterTypes != null) { for (int i = 0; i < genericParameterTypes.Length; ++i) { key += "|" + genericParameterTypes[i].ToString(); } } #endregion DynamicMethodDelegate dmd; lock (cache) { if (cache.ContainsKey(key)) { dmd = cache[key]; } else { //动态创建一个封装了泛型方法调用的非泛型方法,并返回绑定到他的DynamicMethodDelegate的实例 //返回的动态方法的实现在编译期就是以显式方法调用泛型方法的,因此,最大程度上避免了反射的性能损失 DynamicMethod dm = new DynamicMethod(Guid.NewGuid().ToString("N"), typeof(object), new Type[] { typeof(object[]) }, typeof(string).Module); ILGenerator il = dm.GetILGenerator(); #region 创建所有方法的参数的本地变量 //首先获得目标方法的MethodInfo MethodInfo makeGenericMethodInfo; if (genericParameterTypes != null && genericParameterTypes.Length > 0) { makeGenericMethodInfo = genericMethodInfo.MakeGenericMethod(genericParameterTypes); } else { makeGenericMethodInfo = genericMethodInfo; } //声明本地变量 ParameterInfo[] pis = makeGenericMethodInfo.GetParameters(); for (int i = 0; i < pis.Length; ++i) { il.DeclareLocal(pis[i].ParameterType); } #endregion #region 从paramObjs参数中解析所有参数值到本地变量中 for (int i = 0; i < pis.Length; ++i) { il.Emit(OpCodes.Ldarg_0); LoadIndex(il, i); il.Emit(OpCodes.Ldelem_Ref); if (pis[i].ParameterType.IsValueType) { il.Emit(OpCodes.Unbox_Any, pis[i].ParameterType); } else if (pis[i].ParameterType != typeof(object)) { il.Emit(OpCodes.Castclass, pis[i].ParameterType); } StoreLocal(il, i); } #endregion #region 执行目标方法 for (int i = 0; i < pis.Length; ++i) { LoadLocal(il, i); } if (makeGenericMethodInfo.IsStatic) { il.Emit(OpCodes.Call, makeGenericMethodInfo); } else { throw new NotImplementedException("暂时还没有实现该功能!"); } if (makeGenericMethodInfo.ReturnType == typeof(void)) { il.Emit(OpCodes.Ldnull); } #endregion il.Emit(OpCodes.Ret); dmd = (DynamicMethodDelegate)dm.CreateDelegate(typeof(DynamicMethodDelegate)); cache.Add(key, dmd); } } return dmd; }
/// <summary> /// Initialzes a new instance of <see cref="InvalidSignatureException"/> /// </summary> /// <param name="expectedSignature"><see cref="MethodInfo"/> that represents the expected signature</param> public InvalidSignatureException(MethodInfo expectedSignature) : base(string.Format("Method '{0}' was invoked with the wrong signature, expected: {1}", expectedSignature.Name, expectedSignature.ToString())) { }
public object GetRealObject(StreamingContext context) { MemberTypes memberType = this._memberType; switch (memberType) { case MemberTypes.Constructor: { ConstructorInfo[] constructors = this._reflectedType.GetConstructors(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); for (int i = 0; i < constructors.Length; i++) { if (constructors[i].ToString().Equals(this._memberSignature)) { return(constructors[i]); } } throw new SerializationException(string.Format("Could not find constructor '{0}' in type '{1}'", this._memberSignature, this._reflectedType)); } case MemberTypes.Event: { EventInfo @event = this._reflectedType.GetEvent(this._memberName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (@event != null) { return(@event); } throw new SerializationException(string.Format("Could not find event '{0}' in type '{1}'", this._memberName, this._reflectedType)); } default: { if (memberType != MemberTypes.Property) { throw new SerializationException(string.Format("Unhandled MemberType {0}", this._memberType)); } PropertyInfo property = this._reflectedType.GetProperty(this._memberName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (property != null) { return(property); } throw new SerializationException(string.Format("Could not find property '{0}' in type '{1}'", this._memberName, this._reflectedType)); } case MemberTypes.Field: { FieldInfo field = this._reflectedType.GetField(this._memberName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); if (field != null) { return(field); } throw new SerializationException(string.Format("Could not find field '{0}' in type '{1}'", this._memberName, this._reflectedType)); } case MemberTypes.Method: { MethodInfo[] methods = this._reflectedType.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); for (int j = 0; j < methods.Length; j++) { if (methods[j].ToString().Equals(this._memberSignature)) { return(methods[j]); } if (this._genericArguments != null && methods[j].IsGenericMethod && methods[j].GetGenericArguments().Length == this._genericArguments.Length) { MethodInfo methodInfo = methods[j].MakeGenericMethod(this._genericArguments); if (methodInfo.ToString() == this._memberSignature) { return(methodInfo); } } } throw new SerializationException(string.Format("Could not find method '{0}' in type '{1}'", this._memberSignature, this._reflectedType)); } } }
public void Register(object id, MethodInfo method) { bool context = false; XQueryFunctionRecord rec = new XQueryFunctionRecord(); rec.id = id; object[] attrs = method.GetCustomAttributes(typeof(XQuerySignatureAttribute), false); XQuerySignatureAttribute sig = null; if (attrs.Length > 0) sig = (XQuerySignatureAttribute)attrs[0]; ParameterInfo[] parameter_info = method.GetParameters(); List<XQuerySequenceType> type_list = new List<XQuerySequenceType>(); int implict = -1; foreach (ParameterInfo pi in parameter_info) { if (pi.ParameterType == typeof(IContextProvider)) { if (context) throw new ArgumentException(pi.Name); context = true; continue; } bool customized = false; bool variableParam = false; object[] pi_attrs = pi.GetCustomAttributes(false); foreach (object pi_atr in pi_attrs) { if (pi_atr is System.ParamArrayAttribute) variableParam = true; else if (pi_atr is ImplictAttribute) { customized = true; if (implict != -1) throw new ArgumentException(pi.Name); implict = pi.Position; } else { XQueryParameterAttribute xattr = pi_atr as XQueryParameterAttribute; if (xattr != null) { type_list.Add(new XQuerySequenceType(xattr.TypeCode, xattr.Cardinality, variableParam ? pi.ParameterType.GetElementType() : pi.ParameterType)); customized = true; break; } } } if (!customized) { if (pi.ParameterType == typeof(XQueryNodeIterator)) type_list.Add(new XQuerySequenceType(XmlTypeCode.Item, XmlTypeCardinality.ZeroOrMore, pi.ParameterType)); else type_list.Add(new XQuerySequenceType(pi.ParameterType, XmlTypeCardinality.One)); } } if (sig != null && sig.Return != XmlTypeCode.None) rec.returnType = new XQuerySequenceType(sig.Return, sig.Cardinality, method.ReturnType); else { if (method.ReturnType == typeof(XQueryNodeIterator)) rec.returnType = new XQuerySequenceType(XmlTypeCode.Item, XmlTypeCardinality.ZeroOrMore, method.ReturnType); else rec.returnType = new XQuerySequenceType(method.ReturnType, XmlTypeCardinality.One); } if (sig != null) { rec.variableParams = sig.VariableParams; rec.validationReader = sig.ValidationReaderDemanded; } rec.parameters = type_list.ToArray(); FunctionSocket sock = new FunctionSocket(rec); FunctionSocket next; if (m_table.TryGetValue(rec.id, out next)) { FunctionSocket curr = next; while (curr != null) { if (curr.rec.parameters.Length == rec.parameters.Length && curr.rec.variableParams == rec.variableParams) throw new InvalidOperationException(method.ToString()); curr = curr.next; } sock.next = next; } m_table[rec.id] = sock; GlobalSymbols.DefineStaticOperator(rec.id, method); if (context) { object[] body; Executive.Parameter[] parameters; if (implict == -1) { parameters = new Executive.Parameter[parameter_info.Length - 1]; body = new object[parameter_info.Length + 2]; } else { parameters = new Executive.Parameter[parameter_info.Length - 2]; body = new object[parameter_info.Length + 1]; } int k = 0; int i = 2; body[0] = Funcs.List; body[1] = Lisp.List(Lisp.QUOTE, rec.id); foreach (ParameterInfo pi in parameter_info) { if (pi.Position != implict) { if (pi.ParameterType != typeof(IContextProvider)) { parameters[k] = new Executive.Parameter(); parameters[k].ID = ATOM.Create(String.Format("p{0}", k + 1)); parameters[k].Type = typeof(System.Object); parameters[k].VariableParam = false; body[i++] = parameters[k].ID; k++; } else body[i++] = Lisp.List(Lisp.QUOTE, ID.Context); } } GlobalSymbols.Defmacro(rec.id, parameters, Lisp.List(body)); } }
public object GetMethoParam(MethodInfo info, object param) { if (param is string) { object paraObject = null; try { paraObject = GetStringObject(info, param.ToString()); } catch (Exception ex) { var friendlyEx = new UserFriendlyException("{0} 方法的请求参数出错".Fill(info.ToString())); friendlyEx.InnerException = ex; throw friendlyEx; } return paraObject; } else if (param is List<HttpPostedFile>) { return GetFileObject(info, param); } throw new UserFriendlyException("请求的参数类型错误, 目前只支持文件和数据类型"); }
private string getFunc(MethodInfo meth) { List<string> listTemp = util.getListValueWithToken(meth.ToString(), '('); string func = listTemp[0] + "("; ParameterInfo[] pis = meth.GetParameters(); int n = pis.Length; if (n > 0) { for (int j = 0; j < n - 1; j++) { ParameterInfo info = pis[j]; func += info.ParameterType.Name + " " + info.Name + ","; } ParameterInfo lastinfo = pis[n - 1]; func += lastinfo.ParameterType.Name + " " + lastinfo.Name; } func += ")"; return func; }
public static void GetSerializationInfo(SerializationInfo info, MethodInfo m) { Type[] genericArguments = (m.IsGenericMethod & !m.IsGenericMethodDefinition) ? m.GetGenericArguments() : null; GetSerializationInfo(info, m.Name, m.ReflectedType, m.ToString(), m.SerializationToString(), MemberTypes.Method, genericArguments); }
private static Boolean MethodsEqual(MethodInfo aMethod, MethodInfo bMethod) { //TODO: Compare all arguments, custom attributes, etc. return aMethod.ToString() == bMethod.ToString(); }
internal void Call(MethodInfo methodInfo) { if (methodInfo.IsVirtual) { if (this.codeGenTrace != CodeGenTrace.None) { this.EmitSourceInstruction("Callvirt " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString()); } this.ilGen.Emit(OpCodes.Callvirt, methodInfo); } else if (methodInfo.IsStatic) { if (this.codeGenTrace != CodeGenTrace.None) { this.EmitSourceInstruction("Static Call " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString()); } this.ilGen.Emit(OpCodes.Call, methodInfo); } else { if (this.codeGenTrace != CodeGenTrace.None) { this.EmitSourceInstruction("Call " + methodInfo.ToString() + " on type " + methodInfo.DeclaringType.ToString()); } this.ilGen.Emit(OpCodes.Call, methodInfo); } }
/// <summary> /// Checks if the method has the same signature as a method that was marked as /// one that should generate a new vtable slot. /// </summary> public bool ShouldCreateNewSlot(MethodInfo method) { string methodStr = method.ToString(); foreach (MethodInfo candidate in _generateNewSlot) { if (candidate.ToString() == methodStr) return true; } return false; }
[System.Security.SecurityCritical] // auto-generated public virtual Object GetRealObject(StreamingContext context) { if (m_memberName == null || m_reflectedType == null || m_memberType == 0) { throw new SerializationException(Environment.GetResourceString(ResId.Serialization_InsufficientState)); } BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.OptionalParamBinding; switch (m_memberType) { #region case MemberTypes.Field: case MemberTypes.Field: { FieldInfo[] fields = m_reflectedType.GetMember(m_memberName, MemberTypes.Field, bindingFlags) as FieldInfo[]; if (fields.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", m_memberName)); } return(fields[0]); } #endregion #region case MemberTypes.Event: case MemberTypes.Event: { EventInfo[] events = m_reflectedType.GetMember(m_memberName, MemberTypes.Event, bindingFlags) as EventInfo[]; if (events.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", m_memberName)); } return(events[0]); } #endregion #region case MemberTypes.Property: case MemberTypes.Property: { PropertyInfo[] properties = m_reflectedType.GetMember(m_memberName, MemberTypes.Property, bindingFlags) as PropertyInfo[]; if (properties.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", m_memberName)); } if (properties.Length == 1) { return(properties[0]); } if (properties.Length > 1) { for (int i = 0; i < properties.Length; i++) { if (m_signature2 != null) { if (((RuntimePropertyInfo)properties[i]).SerializationToString().Equals(m_signature2)) { return(properties[i]); } } else { if ((properties[i]).ToString().Equals(m_signature)) { return(properties[i]); } } } } throw new SerializationException(Environment.GetResourceString(ResId.Serialization_UnknownMember, m_memberName)); } #endregion #region case MemberTypes.Constructor: case MemberTypes.Constructor: { if (m_signature == null) { throw new SerializationException(Environment.GetResourceString(ResId.Serialization_NullSignature)); } ConstructorInfo[] constructors = m_reflectedType.GetMember(m_memberName, MemberTypes.Constructor, bindingFlags) as ConstructorInfo[]; if (constructors.Length == 1) { return(constructors[0]); } if (constructors.Length > 1) { for (int i = 0; i < constructors.Length; i++) { if (m_signature2 != null) { if (((RuntimeConstructorInfo)constructors[i]).SerializationToString().Equals(m_signature2)) { return(constructors[i]); } } else { if (constructors[i].ToString().Equals(m_signature)) { return(constructors[i]); } } } } throw new SerializationException(Environment.GetResourceString(ResId.Serialization_UnknownMember, m_memberName)); } #endregion #region case MemberTypes.Method: case MemberTypes.Method: { MethodInfo methodInfo = null; if (m_signature == null) { throw new SerializationException(Environment.GetResourceString(ResId.Serialization_NullSignature)); } Type[] genericArguments = m_info.GetValueNoThrow("GenericArguments", typeof(Type[])) as Type[]; MethodInfo[] methods = m_reflectedType.GetMember(m_memberName, MemberTypes.Method, bindingFlags) as MethodInfo[]; if (methods.Length == 1) { methodInfo = methods[0]; } else if (methods.Length > 1) { for (int i = 0; i < methods.Length; i++) { if (m_signature2 != null) { if (((RuntimeMethodInfo)methods[i]).SerializationToString().Equals(m_signature2)) { methodInfo = methods[i]; break; } } else { if (methods[i].ToString().Equals(m_signature)) { methodInfo = methods[i]; break; } } // Handle generic methods specially since the signature match above probably won't work (the candidate // method info hasn't been instantiated). If our target method is generic as well we can skip this. if (genericArguments != null && methods[i].IsGenericMethod) { if (methods[i].GetGenericArguments().Length == genericArguments.Length) { MethodInfo candidateMethod = methods[i].MakeGenericMethod(genericArguments); if (m_signature2 != null) { if (((RuntimeMethodInfo)candidateMethod).SerializationToString().Equals(m_signature2)) { methodInfo = candidateMethod; break; } } else { if (candidateMethod.ToString().Equals(m_signature)) { methodInfo = candidateMethod; break; } } } } } } if (methodInfo == null) { throw new SerializationException(Environment.GetResourceString(ResId.Serialization_UnknownMember, m_memberName)); } if (!methodInfo.IsGenericMethodDefinition) { return(methodInfo); } if (genericArguments == null) { return(methodInfo); } if (genericArguments[0] == null) { return(null); } return(methodInfo.MakeGenericMethod(genericArguments)); } #endregion default: throw new ArgumentException(Environment.GetResourceString("Serialization_MemberTypeNotRecognized")); } }
/// <summary>Writes XML documenting a method.</summary> /// <param name="writer">XmlWriter to write on.</param> /// <param name="method">Method to document.</param> /// <param name="inherited">true if a declaringType attribute should be included.</param> /// <param name="overload">If > 0, indicates this it the nth overloaded method with the same name.</param> /// <param name="hiding">true if this method hides methods of the base class with the same signature.</param> private void WriteMethod(XmlWriter writer, MethodInfo method, bool inherited, int overload, bool hiding) { if (method != null) { string memberName = MemberID.GetMemberID(method); string name = method.Name; string interfaceName = null; name = name.Replace('+', '.'); int lastIndexOfDot = name.LastIndexOf('.'); if (lastIndexOfDot != -1) { //this is an explicit interface implementation. if we don't want //to document them, get out of here quick... if (!this.rep.DocumentExplicitInterfaceImplementations) return; interfaceName = name.Substring(0, lastIndexOfDot); lastIndexOfDot = interfaceName.LastIndexOf('.'); if (lastIndexOfDot != -1) name = name.Substring(lastIndexOfDot + 1); //check if we want to document this interface. ImplementsInfo implements = implementations[method.ToString()]; if (implements == null) return; } writer.WriteStartElement("method"); writer.WriteAttributeString("name", name); writer.WriteAttributeString("id", memberName); writer.WriteAttributeString("access", GetMethodAccessValue(method)); writer.WriteAttributeString("contract", GetMethodContractValue(method)); Type t = method.ReturnType; writer.WriteAttributeString("returnType", MemberID.GetTypeName(t)); writer.WriteAttributeString("valueType", t.IsValueType.ToString().ToLower()); if (inherited) { writer.WriteAttributeString("declaringType", MemberID.GetDeclaringTypeName(method)); } if (overload > 0) { writer.WriteAttributeString("overload", overload.ToString()); } if (!IsMemberSafe(method)) writer.WriteAttributeString("unsafe", "true"); if (hiding) { writer.WriteAttributeString("hiding", "true"); } if (interfaceName != null) { writer.WriteAttributeString("interface", interfaceName); } if (inherited) { WriteInheritedDocumentation(writer, memberName, method.DeclaringType); } else { WriteMethodDocumentation(writer, memberName, method, true); } WriteCustomAttributes(writer, method); foreach (ParameterInfo parameter in method.GetParameters()) { WriteParameter(writer, MemberID.GetMemberID(method), parameter); } if (implementations != null) { ImplementsInfo implements = implementations[method.ToString()]; if (implements != null) { writer.WriteStartElement("implements"); writer.WriteAttributeString("name", implements.InterfaceMethod.Name); writer.WriteAttributeString("id", MemberID.GetMemberID((MethodBase)implements.InterfaceMethod)); writer.WriteAttributeString("interface", MemberDisplayName.GetMemberDisplayName(implements.InterfaceType)); writer.WriteAttributeString("interfaceId", MemberID.GetMemberID(implements.InterfaceType)); writer.WriteAttributeString("declaringType", implements.InterfaceType.FullName.Replace('+', '.')); writer.WriteEndElement(); } } writer.WriteEndElement(); } }
public object GetRealObject(StreamingContext context) { switch (_memberType) { case MemberTypes.Constructor: ConstructorInfo [] ctors; ctors = _reflectedType.GetConstructors(DefaultBinding); for (int i = 0; i < ctors.Length; i++) { if (ctors[i].ToString().Equals(_memberSignature)) { return(ctors[i]); } } throw new SerializationException(String.Format("Could not find constructor '{0}' in type '{1}'", _memberSignature, _reflectedType)); case MemberTypes.Method: MethodInfo [] methods; methods = _reflectedType.GetMethods(DefaultBinding); for (int i = 0; i < methods.Length; i++) { if ((methods[i]).ToString().Equals(_memberSignature)) { return(methods[i]); } else if (_genericArguments != null && methods[i].IsGenericMethod && methods[i].GetGenericArguments().Length == _genericArguments.Length) { MethodInfo mi = methods[i].MakeGenericMethod(_genericArguments); if (mi.ToString() == _memberSignature) { return(mi); } } } throw new SerializationException(String.Format("Could not find method '{0}' in type '{1}'", _memberSignature, _reflectedType)); case MemberTypes.Field: FieldInfo fi = _reflectedType.GetField(_memberName, DefaultBinding); if (fi != null) { return(fi); } throw new SerializationException(String.Format("Could not find field '{0}' in type '{1}'", _memberName, _reflectedType)); case MemberTypes.Property: PropertyInfo pi = _reflectedType.GetProperty(_memberName, DefaultBinding); if (pi != null) { return(pi); } throw new SerializationException(String.Format("Could not find property '{0}' in type '{1}'", _memberName, _reflectedType)); case MemberTypes.Event: EventInfo ei = _reflectedType.GetEvent(_memberName, DefaultBinding); if (ei != null) { return(ei); } throw new SerializationException(String.Format("Could not find event '{0}' in type '{1}'", _memberName, _reflectedType)); default: throw new SerializationException(String.Format("Unhandled MemberType {0}", _memberType)); } }
public virtual object GetRealObject(StreamingContext context) { if (this.m_memberName == null || this.m_reflectedType == (RuntimeType)null || this.m_memberType == (MemberTypes)0) { throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState")); } BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.OptionalParamBinding; switch (this.m_memberType) { case MemberTypes.Constructor: if (this.m_signature == null) { throw new SerializationException(Environment.GetResourceString("Serialization_NullSignature")); } ConstructorInfo[] constructorInfoArray = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Constructor, bindingAttr) as ConstructorInfo[]; if (constructorInfoArray.Length == 1) { return((object)constructorInfoArray[0]); } if (constructorInfoArray.Length > 1) { for (int index = 0; index < constructorInfoArray.Length; ++index) { if (this.m_signature2 != null) { if (((RuntimeConstructorInfo)constructorInfoArray[index]).SerializationToString().Equals(this.m_signature2)) { return((object)constructorInfoArray[index]); } } else if (constructorInfoArray[index].ToString().Equals(this.m_signature)) { return((object)constructorInfoArray[index]); } } } throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", (object)this.m_memberName)); case MemberTypes.Event: EventInfo[] eventInfoArray = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Event, bindingAttr) as EventInfo[]; if (eventInfoArray.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", (object)this.m_memberName)); } return((object)eventInfoArray[0]); case MemberTypes.Field: FieldInfo[] fieldInfoArray = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Field, bindingAttr) as FieldInfo[]; if (fieldInfoArray.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", (object)this.m_memberName)); } return((object)fieldInfoArray[0]); case MemberTypes.Method: MethodInfo methodInfo1 = (MethodInfo)null; if (this.m_signature == null) { throw new SerializationException(Environment.GetResourceString("Serialization_NullSignature")); } Type[] typeArray = this.m_info.GetValueNoThrow("GenericArguments", typeof(Type[])) as Type[]; MethodInfo[] methodInfoArray = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Method, bindingAttr) as MethodInfo[]; if (methodInfoArray.Length == 1) { methodInfo1 = methodInfoArray[0]; } else if (methodInfoArray.Length > 1) { for (int index = 0; index < methodInfoArray.Length; ++index) { if (this.m_signature2 != null) { if (((RuntimeMethodInfo)methodInfoArray[index]).SerializationToString().Equals(this.m_signature2)) { methodInfo1 = methodInfoArray[index]; break; } } else if (methodInfoArray[index].ToString().Equals(this.m_signature)) { methodInfo1 = methodInfoArray[index]; break; } if (typeArray != null && methodInfoArray[index].IsGenericMethod && methodInfoArray[index].GetGenericArguments().Length == typeArray.Length) { MethodInfo methodInfo2 = methodInfoArray[index].MakeGenericMethod(typeArray); if (this.m_signature2 != null) { if (((RuntimeMethodInfo)methodInfo2).SerializationToString().Equals(this.m_signature2)) { methodInfo1 = methodInfo2; break; } } else if (methodInfo2.ToString().Equals(this.m_signature)) { methodInfo1 = methodInfo2; break; } } } } if (methodInfo1 == (MethodInfo)null) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", (object)this.m_memberName)); } if (!methodInfo1.IsGenericMethodDefinition) { return((object)methodInfo1); } if (typeArray == null) { return((object)methodInfo1); } if (typeArray[0] == (Type)null) { return((object)null); } return((object)methodInfo1.MakeGenericMethod(typeArray)); case MemberTypes.Property: PropertyInfo[] propertyInfoArray = this.m_reflectedType.GetMember(this.m_memberName, MemberTypes.Property, bindingAttr) as PropertyInfo[]; if (propertyInfoArray.Length == 0) { throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", (object)this.m_memberName)); } if (propertyInfoArray.Length == 1) { return((object)propertyInfoArray[0]); } if (propertyInfoArray.Length > 1) { for (int index = 0; index < propertyInfoArray.Length; ++index) { if (this.m_signature2 != null) { if (((RuntimePropertyInfo)propertyInfoArray[index]).SerializationToString().Equals(this.m_signature2)) { return((object)propertyInfoArray[index]); } } else if (propertyInfoArray[index].ToString().Equals(this.m_signature)) { return((object)propertyInfoArray[index]); } } } throw new SerializationException(Environment.GetResourceString("Serialization_UnknownMember", (object)this.m_memberName)); default: throw new ArgumentException(Environment.GetResourceString("Serialization_MemberTypeNotRecognized")); } }
void ProcessMethod(System.Reflection.MethodInfo methodInfo) { Debug.WriteLine("Add method " + methodInfo.ToString()); }