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);
}
