private static void RegisterEventTypesAndHandlers(Assembly assembly) { if (assembly == null) { return; } foreach (Type type in assembly.GetTypes()) { foreach (MethodInfo method in type.GetMethods()) { if (!method.IsPublic || !method.IsStatic) { continue; } var descriptorArray = method.GetCustomAttributes(typeof(MyGlobalEventHandler), false); if (descriptorArray != null && descriptorArray.Length > 0) { foreach (var descriptor in descriptorArray) { MyGlobalEventHandler typedDescriptor = (MyGlobalEventHandler)descriptor; RegisterHandler(typedDescriptor.EventDefinitionId, MethodInfoExtensions.CreateDelegate <GlobalEventHandler>(method)); } } } } }
public static MemberTypes MemberType(this MemberInfo member) { var methodInfo = member as MethodInfo; if (methodInfo != null) { return(MethodInfoExtensions.MemberType()); } throw new NotSupportedException(string.Format("Cannot handle '{0}'.", member.GetType())); }
/// <summary> /// 方法表达式 /// </summary> /// <param name="m"></param> /// <returns></returns> protected override System.Linq.Expressions.Expression VisitMethodCall(MethodCallExpression m) { if (m == null) { throw new ArgumentNullException("MethodCallExpression"); } //var obj = Activator.CreateInstance(type); //var val = obj. string format; switch (m.Method.Name) { case "StartsWith": format = " {0} LIKE '{1}%' "; break; case "Contains": format = " {0} LIKE '%{1}%' "; break; case "EndsWith": format = " {0} LIKE '%{1}' "; break; default: var cl = MethodInfoExtensions.GetBaseDefinition(m.Method); var type = Type.GetType(cl.DeclaringType.FullName); if (type.IsAbstract) { var me = type.GetMethod(m.Method.Name); var data = me.Invoke(type, null); } else { var obj = Activator.CreateInstance(type); var me = type.GetMethod(m.Method.Name); var data = me.Invoke(obj, null); } format = " {0} = {1} "; break; } this.Visit(m.Object); this.Visit(m.Arguments[0]); string right = ""; right = this._StringStack.Pop().Trim().Substring(1).SubstringLast(); string left = this._StringStack.Pop(); this._StringStack.Push(String.Format(format, left, right)); return(m); }
private static void CreateFile(Type typeValue, string outputDir, Assembly assembly) { var type = assembly.GetType(typeValue.FullName); var sb = new StringBuilder(); sb.AppendLine("### Events"); sb.AppendLine(); sb.AppendLine("### Functions"); sb.AppendLine(); foreach (var member in typeValue.Members.Values) { Console.Write("\tmember: " + member.ShortName + " ... "); var methodInfo = TypeUtils.GetMethod(type, member); if (methodInfo == null) { Console.WriteLine("(unable to parse)"); continue; } Console.WriteLine("(success)"); var signature = methodInfo.GetSignature(); sb.AppendLine(string.Format("#### `{0}`", signature)); sb.AppendLine("##### Summary"); sb.AppendLine(string.Format("{0}", member.Summary)); sb.AppendLine(); sb.AppendLine("##### Returns"); sb.AppendLine(string.Format("{0}", member.Returns)); sb.AppendLine(); sb.AppendLine("##### Parameters"); sb.AppendLine("| Name | Type | Description |"); sb.AppendLine("| --- | --- | --- |"); foreach (var keyValuePair in member.Params) { var name = keyValuePair.Key; var paramType = MethodInfoExtensions.TypeName(methodInfo.GetParameters().FirstOrDefault(p => p.Name == name).ParameterType); var description = keyValuePair.Value; sb.AppendLine(string.Format("| {0} | {1} | {2} |", name, paramType, description)); } sb.AppendLine(); } var outfile = outputDir + "/" + typeValue.ShortName + ".md"; Console.WriteLine(string.Format("Written output to {0}", outfile)); File.WriteAllText(outfile, sb.ToString()); }
public void GetOriginalDeclaringType_ForOverriddenMethodOnDerivedOfDerivedClass() { MethodInfo MethodInfo = GetMethodInfo <DerivedOfDerivedClassWithDifferentMethods> ("GetInt32"); Assert.That(MethodInfoExtensions.GetOriginalDeclaringType(MethodInfo), Is.SameAs(typeof(ClassWithDifferentMethods))); }
public void GetOriginalDeclaringType_ForNewMethodOnDerivedClass() { MethodInfo MethodInfo = GetMethodInfo <DerivedClassWithDifferentMethods> ("GetString"); Assert.That(MethodInfoExtensions.GetOriginalDeclaringType(MethodInfo), Is.SameAs(typeof(DerivedClassWithDifferentMethods))); }
CallSite CreateCallSite <T1, T2, T3, T4, T5, T6, T7>(MethodInfo info, uint id) { Type[] arguments = new Type[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4), typeof(T5), typeof(T6), typeof(T7) }; var p = arguments.Select(s => Expression.Parameter(s)).ToArray(); Expression call; if (info.IsStatic) { call = Expression.Call(info, p.Skip(1).Where(s => s.Type != typeof(DBNull)).ToArray()); } else { call = Expression.Call(p.First(), info, p.Skip(1).Where(s => s.Type != typeof(DBNull)).ToArray()); } var handler = Expression.Lambda <Action <T1, T2, T3, T4, T5, T6, T7> >(call, p).Compile(); var eventAttribute = info.GetCustomAttribute <EventAttribute>(); var serverAttribute = info.GetCustomAttribute <ServerAttribute>(); CallSiteFlags flags = CallSiteFlags.None; if (serverAttribute != null) { flags |= CallSiteFlags.Server; if (serverAttribute.ExceptLocal) { flags |= CallSiteFlags.ExceptLocal; } } if (info.HasAttribute <ClientAttribute>()) { flags |= CallSiteFlags.Client; } if (info.HasAttribute <BroadcastAttribute>()) { flags |= CallSiteFlags.Broadcast; } if (info.HasAttribute <BroadcastExceptAttribute>()) { flags |= CallSiteFlags.BroadcastExcept; } if (info.HasAttribute <ReliableAttribute>()) { flags |= CallSiteFlags.Reliable; } if (info.HasAttribute <RefreshReplicableAttribute>()) { flags |= CallSiteFlags.RefreshReplicable; } if (info.HasAttribute <BlockingAttribute>()) { flags |= CallSiteFlags.Blocking; } SerializeDelegate <T1, T2, T3, T4, T5, T6, T7> serializer = null; Func <T1, T2, T3, T4, T5, T6, T7, bool> validator = null; if (eventAttribute.Serialization != null) { var method = info.DeclaringType.GetMethod(eventAttribute.Serialization, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly); if (method == null) { throw new InvalidOperationException(String.Format("Serialization method '{0}' for event '{1}' defined by type '{2}' not found", eventAttribute.Serialization, info.Name, info.DeclaringType.Name)); } if (!method.GetParameters().Skip(1).All(s => s.ParameterType.IsByRef)) { throw new InvalidOperationException(String.Format("Serialization method '{0}' for event '{1}' defined by type '{2}' must have all arguments passed with 'ref' keyword (except BitStream)", eventAttribute.Serialization, info.Name, info.DeclaringType.Name)); } var args = MethodInfoExtensions.ExtractParameterExpressionsFrom <SerializeDelegate <T1, T2, T3, T4, T5, T6, T7> >(); var c = Expression.Call(args.First(), method, args.Skip(1).Where(s => s.Type != typeof(DBNull)).ToArray()); serializer = Expression.Lambda <SerializeDelegate <T1, T2, T3, T4, T5, T6, T7> >(c, args).Compile(); } if (serverAttribute != null && serverAttribute.Validation != null) { var method = info.DeclaringType.GetMethod(serverAttribute.Validation, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly); if (method == null) { throw new InvalidOperationException(String.Format("Validation method '{0}' for event '{1}' defined by type '{2}' not found", serverAttribute.Validation, info.Name, info.DeclaringType.Name)); } var args = MethodInfoExtensions.ExtractParameterExpressionsFrom <Func <T1, T2, T3, T4, T5, T6, T7, bool> >(); var c = Expression.Call(args.First(), method, args.Skip(1).Where(s => s.Type != typeof(DBNull)).ToArray()); validator = Expression.Lambda <Func <T1, T2, T3, T4, T5, T6, T7, bool> >(c, args).Compile(); } serializer = serializer ?? CreateSerializer <T1, T2, T3, T4, T5, T6, T7>(info); validator = validator ?? CreateValidator <T1, T2, T3, T4, T5, T6, T7>(); return(new CallSite <T1, T2, T3, T4, T5, T6, T7>(Type, id, info, flags, handler, serializer, validator)); }
public void CompileStaticInvokerFailsWithNullThis() { var e = Assert.Throws <ArgumentNullException>(() => MethodInfoExtensions.CompileStaticInvoker(null)); Assert.Equal("method", e.ParamName); }
private static string MakeAddition(MethodInfo m, bool withType) { var parameters = m.GetParameters(); var addition = ""; if (m.IsGenericMethodDefinition || m.IsGenericMethod) { // return m.GetSignature(true); /*addition += '<'; * foreach (var genericArgument in m.GetGenericArguments()) * { * if (addition.Last() == '<') * addition += genericArgument.FullName; * else * addition += ','+genericArgument.FullName; * } * addition += '>';*/ //addition=addition.Insert(0,@"<"+ +@">") } addition += "("; for (var i = 0; i < parameters.Length; i++) { if (MethodInfoExtensions.IsParamArray(parameters[i])) { for (var j = 1; j < 3; j++) { //var parameterName = parameters[i].Name + "1, " + parameters[i].Name + "2, ..."; addition += withType ? TypeNameToAlias(parameters[i].ParameterType.Name.Replace("[]", "")) + " " + parameters[i].Name + j + ", " : parameters[i].Name + j + ","; } addition += " ..."; } else { addition += withType ? TypeNameToAlias(parameters[i].ParameterType.Name) + " " + parameters[i].Name + ", " : parameters[i].Name + ","; } } if (addition.EndsWith(", ")) { addition = addition.Substring(0, addition.Length - 2) + ')'; } else if (addition.EndsWith(",")) { addition = addition.Substring(0, addition.Length - 1) + ')'; } else { addition += ")"; } return(addition); }