public void CreateProxiedMethod(FieldInfo field, MethodInfo method, TypeBuilder typeBuilder)
{
const MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig |
MethodAttributes.Virtual;
ParameterInfo[] parameters = method.GetParameters();
MethodBuilder methodBuilder = typeBuilder.DefineMethod(method.Name, methodAttributes,
CallingConventions.HasThis, method.ReturnType,
parameters.Select(param => param.ParameterType).ToArray());
System.Type[] typeArgs = method.GetGenericArguments();
if (typeArgs.Length > 0)
{
var typeNames = new List<string>();
for (int index = 0; index < typeArgs.Length; index++)
{
typeNames.Add(string.Format("T{0}", index));
}
methodBuilder.DefineGenericParameters(typeNames.ToArray());
}
ILGenerator IL = methodBuilder.GetILGenerator();
Debug.Assert(MethodBodyEmitter != null);
MethodBodyEmitter.EmitMethodBody(IL, method, field);
}
private static bool IsSameMethod(MethodInfo first, MethodInfo second)
{
return first.DeclaringType == second.DeclaringType
&& first.MetadataToken == second.MetadataToken
&& first.Module == second.Module
&& first.GetGenericArguments().SequenceEqual(second.GetGenericArguments());
}
public IAutoFactoryMethodDefinition GetMethodDefinition(MethodInfo methodInfo, IList<object> arguments)
{
if (methodInfo.Name.StartsWith("GetNames", StringComparison.InvariantCultureIgnoreCase)
&& methodInfo.IsGenericMethod
&& methodInfo.GetGenericArguments().Any()
&& (methodInfo.ReturnType.IsAssignableFrom(typeof(List<string>))))
{
return new AutoFactoryMethodDefinition(AutoFactoryMethodType.GetNames, methodInfo.GetGenericArguments().First(), null, null);
}
var pluginType = methodInfo.ReturnType;
// do nothing with void methods for now
if (pluginType == typeof(void))
{
return null;
}
var name = tryGetInstanceName(methodInfo, arguments);
var isNamed = !string.IsNullOrEmpty(name);
var explicitArguments = getExplicitArguments(isNamed, methodInfo, arguments);
return new AutoFactoryMethodDefinition(AutoFactoryMethodType.GetInstance, pluginType, name, explicitArguments);
}
protected static string GetGenericDeclarationInformation(MethodInfo method, Assembly containingAssembly, bool isDeclaration)
{
var builder = new StringBuilder();
if(method != null)
{
var genericArguments = method.GetGenericArguments();
builder.Append("<");
var descriptors = new List<string>();
if(genericArguments != null)
{
foreach(var genericArgument in genericArguments)
{
var elementType = genericArgument.GetRootElementType();
if(isDeclaration)
{
descriptors.Add(elementType.Name);
}
else
{
descriptors.Add(new TypeDescriptor(elementType, containingAssembly, true).Value);
}
}
}
builder.Append(string.Join(", ", descriptors.ToArray()));
builder.Append(">");
}
return builder.ToString();
}
public void Method(
MethodInfo mi
, int argToTest)
{
var genericArgsInfo = mi.GetGenericArguments();
int aggregateCount = genericArgsInfo.Count(t => Regex.IsMatch(t.Name, "^TA"));
if (genericArgsInfo.Length > 0)
mi = mi.MakeGenericMethod(genericArgsInfo.Select(
p => p.Name == "TSourceAggregates" ? typeof(Tuple<int, int>) : typeof(int)).ToArray());
var paramInfos = mi.GetParameters();
var callArguments = paramInfos.Select((p, i) =>
{
object arg = null;
if (p.ParameterType.IsValueType)
arg = Activator.CreateInstance(p.ParameterType);
else if (i < argToTest)
arg = ConstructArgument(p.ParameterType, aggregateCount);
return Expression.Constant(arg, p.ParameterType);
});
Action callWithBoundArguments = Expression.Lambda<Action>(Expression.Call(mi, callArguments)).Compile();
Assert.That(new TestDelegate(callWithBoundArguments), Throws.TypeOf(typeof(ArgumentNullException))
.With.Property("ParamName").EqualTo(paramInfos[argToTest].Name));
}
protected override Type GetComponentType(MethodInfo method, object[] arguments)
{
int genericLength = method.GetGenericArguments().Length;
if (genericLength == 1)
{
bool isView = typeof (IView).IsAssignableFrom(method.GetGenericArguments()[0]);
if (method.Name == "CreatePresenter" && isView)
{
return method.GetGenericArguments()[0];
}
}
return base.GetComponentType(method, arguments);
}
protected virtual MethodInfo VisitMethod(MethodInfo methodToSearch)
{
var newReflectedType = VisitType(methodToSearch.ReflectedType);
if (newReflectedType != methodToSearch.ReflectedType)
{
methodToSearch = newReflectedType.GetMethod(methodToSearch.Name,
(methodToSearch.IsStatic ? BindingFlags.Static : BindingFlags.Instance)
| (methodToSearch.IsPublic
? BindingFlags.Public
: BindingFlags.NonPublic),
null,
methodToSearch.GetParameters().Select(x => x.ParameterType).ToArray(),
null);
}
if (!methodToSearch.IsGenericMethod)
return methodToSearch;
var genArgs = methodToSearch.GetGenericArguments();
var newGenArgs = genArgs.Select(VisitType).ToArray();
if (genArgs.SequenceEqual(newGenArgs))
return methodToSearch;
return methodToSearch.GetGenericMethodDefinition().MakeGenericMethod(newGenArgs);
}
/// <summary>
/// Gets the display name for a method as used by NUnit.
/// </summary>
/// <param name="method">The method for which a display name is needed.</param>
/// <param name="arglist">The arguments provided.</param>
/// <returns>The display name for the method</returns>
public static string GetDisplayName(MethodInfo method, object[] arglist)
{
StringBuilder sb = new StringBuilder(method.Name);
#if CLR_2_0 || CLR_4_0
if (method.IsGenericMethod)
{
sb.Append("<");
int cnt = 0;
foreach (Type t in method.GetGenericArguments())
{
if (cnt++ > 0) sb.Append(",");
sb.Append(t.Name);
}
sb.Append(">");
}
#endif
if (arglist != null)
{
sb.Append("(");
for (int i = 0; i < arglist.Length; i++)
{
if (i > 0) sb.Append(",");
sb.Append(GetDisplayString(arglist[i]));
}
sb.Append(")");
}
return sb.ToString();
}
public static Type[] ResolveTypeArguments(MethodInfo method, object[] parameters)
{
var genericArguments = method.GetGenericArguments();
var parameterTypes = method.GetParameters().Select(p => p.ParameterType).ToArray();
return genericArguments.Select(genericArgument => ResolveTypeArgument(genericArgument, parameterTypes, parameters)).ToArray();
}
bool CanCompareGenericMethods(MethodInfo a, MethodInfo b)
{
return
AreEquivalentDefinitions(a, b)
&& TypesAreAllEquivalent(ParameterTypes(a), ParameterTypes(b))
&& TypesAreAllEquivalent(a.GetGenericArguments(), b.GetGenericArguments());
}
protected static GenericTypeParameterBuilder[] CloneGenericMethodArguments(MethodInfo source, MethodBuilder destination)
{
var genericArgs = source.GetGenericArguments();
if (genericArgs.Length == 0)
{
return new GenericTypeParameterBuilder[0];
}
var names = new string[genericArgs.Length];
for (var i = 0; i < genericArgs.Length; i++)
{
names[i] = genericArgs[i].Name;
}
var genericTypeParameterBuilders = destination.DefineGenericParameters(names);
for (var i = 0; i < genericTypeParameterBuilders.Length; i++)
{
var genericArgConstraints = genericArgs[i].GetGenericParameterConstraints();
for (var j = 0; j < genericArgConstraints.Length; j++)
{
genericTypeParameterBuilders[i].SetBaseTypeConstraint(genericArgConstraints[j]);
}
}
return genericTypeParameterBuilders;
}
public static Method CreateMethod(MethodInfo methodInfo, TsType parent)
{
var method = new Method(methodInfo.Name, parent)
{
IsStatic = methodInfo.IsStatic
};
var parameters = methodInfo.GetParameters();
foreach (var parameterInfo in parameters)
{
method.Parameters.Add(MethodParameterFactory.Create(parameterInfo, method));
}
if (methodInfo.IsGenericMethod)
{
var genericArguments = methodInfo.GetGenericArguments();
foreach (var argument in genericArguments)
{
method.Generics.Add(new GenericDefinition(argument.Name));
}
}
if (methodInfo.ReturnType != typeof(void))
{
method.Return = new TsUndefined { UnderlyingType = methodInfo.ReturnType };
}
return method;
}
public virtual void GenerateMethod(PropertyInfo pi, MethodInfo mi, ILGenerator gen)
{
gen.DeclareLocal(typeof(Type));
gen.EmitLdType(mi.GetGenericArguments()[0]);
gen.Emit(OpCodes.Stloc_0);
foreach (var scc in _pcb.ProxyCoderContext.MixinCoderContexts.SelectMany(a => a.SubjectCoderContexts))
{
var smes = scc.GetPerSubjectCoder<ISubjectMethodExistsPerSubjectCoder>();
if (smes==null)
continue;
var falseTarget = gen.DefineLabel();
gen.Emit(OpCodes.Ldloc_0);
gen.EmitLdType(scc.SubjectType);
gen.EmitOpEqualityCall(typeof(Type));
gen.Emit(OpCodes.Brfalse, falseTarget);
smes.PutSubjectMethodExistsOnStack(gen);
// Required for PE Verification
gen.Emit(OpCodes.Castclass, mi.ReturnType);
gen.Emit(OpCodes.Ret);
gen.MarkLabel(falseTarget);
}
gen.Emit(OpCodes.Ldnull);
gen.Emit(OpCodes.Ret);
}
/// <summary>
/// Implements a method as a no operation method. Method can be virtual, abstract or not.
/// </summary>
/// <param name="tB">The <see cref="TypeBuilder"/> for the new type.</param>
/// <param name="method">The method to implement.</param>
/// <param name="isVirtual">Defaults to false: the method is sealed. True to keep the method virtual. </param>
/// <returns>The <see cref="MethodBuilder"/> to enable, for instance, creation of custom attributes on the method.</returns>
public static MethodBuilder ImplementEmptyStubMethod( TypeBuilder tB, MethodInfo method, bool isVirtual = false )
{
if( tB == null ) throw new ArgumentNullException( "tB" );
if( method == null ) throw new ArgumentNullException( "method" );
ParameterInfo[] parameters = method.GetParameters();
Type[] parametersTypes = ReflectionHelper.CreateParametersType( parameters );
Type returnType = method.ReturnType;
MethodAttributes mA = method.Attributes & ~(MethodAttributes.Abstract | MethodAttributes.VtableLayoutMask);
if( isVirtual ) mA |= MethodAttributes.Virtual;
MethodBuilder mB = tB.DefineMethod( method.Name, mA );
if( method.ContainsGenericParameters )
{
int i = 0;
Type[] genericArguments = method.GetGenericArguments();
string[] names = genericArguments.Select( t => String.Format( "T{0}", i++ ) ).ToArray();
var genericParameters = mB.DefineGenericParameters( names );
for( i = 0; i < names.Length; ++i )
{
var genericTypeArgument = genericArguments[i].GetTypeInfo();
GenericTypeParameterBuilder genericTypeBuilder = genericParameters[i];
genericTypeBuilder.SetGenericParameterAttributes( genericTypeArgument.GenericParameterAttributes );
genericTypeBuilder.SetInterfaceConstraints( genericTypeArgument.GetGenericParameterConstraints() );
}
}
mB.SetReturnType( method.ReturnType );
mB.SetParameters( ReflectionHelper.CreateParametersType( parameters ) );
EmitEmptyImplementation( mB, returnType, parameters );
return mB;
}
internal static string GetMethodSignature(System.Reflection.MethodInfo mi)
{
if (mi == null)
{
return(string.Empty);
}
StringBuilder sb = new StringBuilder(0x80);
sb.Append(mi.Name);
AppendGenericArguments(mi.GetGenericArguments(), sb);
sb.Append("(");
ParameterInfo[] parameters = mi.GetParameters();
foreach (ParameterInfo info in parameters)
{
AppendTypeName(info.ParameterType, false, sb);
sb.Append(" " + info.Name);
if ((info.Position + 1) < parameters.Length)
{
sb.Append(", ");
}
}
sb.Append(")");
if (mi.ReturnType != typeof(void))
{
StringBuilder builder2 = new StringBuilder();
AppendTypeName(mi.ReturnType, false, builder2);
return(System.Design.SR.GetString("ObjectDataSourceMethodEditor_SignatureFormat", new object[] { sb, builder2 }));
}
return(sb.ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodInvokeInfo"/> class.
/// </summary>
/// <param name="method">The method.</param>
public MethodInvokeInfo(MethodInfo method)
{
name = method.Name;
declaringType = method.DeclaringType;
genericArguments = method.GetGenericArguments();
parameters = method.GetParameters();
returnType = method.ReturnType;
}
public static void EnsureSatisfiesClassConstraints(MethodInfo reflectionMethodInfo)
{
MethodInfo genericMethodDefinition = reflectionMethodInfo.GetGenericMethodDefinition();
TypeInfo[] methodArguments = TypesToTypeInfos(reflectionMethodInfo.GetGenericArguments());
TypeInfo[] methodParameters = TypesToTypeInfos(genericMethodDefinition.GetGenericArguments());
TypeInfo[] typeArguments = TypesToTypeInfos(reflectionMethodInfo.DeclaringType.GetGenericArguments());
SigTypeContext typeContext = new SigTypeContext(typeArguments, methodArguments);
EnsureSatisfiesClassConstraints(methodParameters, methodArguments, genericMethodDefinition, typeContext);
}
static string PrettyPrintGenericArguments(MethodInfo mi)
{
if (!mi.IsGenericMethodDefinition) {
return "";
}
return "<"
+ string.Join(", ", mi.GetGenericArguments().Select(ObjectToCode.GetCSharpFriendlyTypeName))
+ ">";
}
public static IntPtr[] GenericMethodArguments(MethodInfo m)
{
Type[] types = m.GetGenericArguments();
IntPtr[] ptrTypes = new IntPtr[types.Length];
for (int i = 0; i < types.Length; i++) {
ptrTypes [i] = types [i].TypeHandle.Value;
}
return ptrTypes;
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodMatcher"/> class.
/// </summary>
/// <param name="methodInfo">The expected method reference.</param>
public MethodMatcher(MethodInfo methodInfo)
: base(methodInfo.Name, methodInfo.DeclaringType)
{
if (methodInfo == null) throw new ArgumentNullException("methodInfo");
_methodInfo = methodInfo;
_genericParametersMatcher = new GenericMethodTypeParametersMatcher(_methodInfo.GetGenericArguments());
_expectedParameters = _methodInfo.GetParameters();
}
/// <summary>
/// Returns first generic type argument of a type.
/// </summary>
/// <param name="type"></param>
/// <returns>First generic type argument.</returns>
public static Type GetFirstGenericTypeArgumentOfType(MethodInfo methodInfo)
{
if (!methodInfo.IsGenericMethod)
{
throw new OrmInternalException("The type of the query is not generic");
}
return methodInfo.GetGenericArguments().First();
}
private static bool ArgsMatch(MethodInfo m, ReadOnlyCollection<Expression> args, Type[] typeArgs)
{
ParameterInfo[] parameters = m.GetParameters();
if (parameters.Length != args.Count)
{
return false;
}
if ((!m.IsGenericMethod && (typeArgs != null)) && (typeArgs.Length > 0))
{
return false;
}
if ((!m.IsGenericMethodDefinition && m.IsGenericMethod) && m.ContainsGenericParameters)
{
m = m.GetGenericMethodDefinition();
}
if (m.IsGenericMethodDefinition)
{
if ((typeArgs == null) || (typeArgs.Length == 0))
{
return false;
}
if (m.GetGenericArguments().Length != typeArgs.Length)
{
return false;
}
m = m.MakeGenericMethod(typeArgs);
parameters = m.GetParameters();
}
int index = 0;
int count = args.Count;
while (index < count)
{
Type parameterType = parameters[index].ParameterType;
if (parameterType == null)
{
return false;
}
if (parameterType.IsByRef)
{
parameterType = parameterType.GetElementType();
}
Expression operand = args[index];
if (!parameterType.IsAssignableFrom(operand.Type))
{
if (operand.NodeType == ExpressionType.Quote)
{
operand = ((UnaryExpression) operand).Operand;
}
if (!parameterType.IsAssignableFrom(operand.Type) && !parameterType.IsAssignableFrom(StripExpression(operand.Type)))
{
return false;
}
}
index++;
}
return true;
}
public Type[] GetGenericArgumentsFor(MethodInfo genericMethod)
{
List<Type> types = new List<Type>();
foreach(Type genType in genericMethod.GetGenericArguments())
{
types.Add(name2GenericType[genType.Name]);
}
return types.ToArray();
}
private static string GetGenericParameterText( MethodInfo method )
{
if( ! method.ContainsGenericParameters )
{
return string.Empty;
}
Type[] genericParameters = method.GetGenericArguments();
string args = string.Join( ",", genericParameters.Select( t => t.Name() ) );
return "<" + args + ">";
}
public string Format(MethodInfo methodInfoOfCall, IEnumerable<object> arguments, IEnumerable<int> argumentsToHighlight)
{
string genericInfo = null;
if (methodInfoOfCall.IsGenericMethod)
{
var genericArgs = methodInfoOfCall.GetGenericArguments();
genericInfo = "<" + string.Join(", ", genericArgs.Select(x => x.Name).ToArray()) + ">";
}
return string.Format("{0}{1}({2})", methodInfoOfCall.Name, genericInfo, _argumentsFormatter.Format(arguments, argumentsToHighlight));
}
public bool InitializeProxyMethod(MethodInfo sourceMethod, Type[] types, out MethodInfo proxyMethod)
{
if (types == null) throw new ArgumentNullException("types");
var proxyTypeArgs = new List<Type>();
if (ReflectionHelper.IsGenericType(sourceMethod.DeclaringType))
{
proxyTypeArgs.AddRange(sourceMethod.DeclaringType.GetGenericArguments());
}
if (sourceMethod.IsGenericMethod)
{
proxyTypeArgs.AddRange(sourceMethod.GetGenericArguments());
}
var typeArrayPointer = 0;
var proxyType = this.ProxyType;
if (proxyType.IsGenericTypeDefinition)
{
var typeArgs = new Type[proxyType.GetGenericArguments().Length];
for (int i = 0; i < typeArgs.Length; i++)
{
typeArgs[i] = proxyTypeArgs[typeArrayPointer];
typeArrayPointer++;
}
proxyType = proxyType.MakeGenericType(typeArgs);
}
if (proxyTypeArgs.Count > typeArrayPointer)
{
var methodParamArgs = new Type[proxyTypeArgs.Count - typeArrayPointer];
for (int i = 0; i < methodParamArgs.Length; i++)
{
methodParamArgs[i] = proxyTypeArgs[i + typeArrayPointer];
}
proxyMethod = proxyType.GetMethods().Select(m =>
{
if (m.IsGenericMethodDefinition && m.Name == MethodName)
{
var methodTypeParameters = m.GetGenericArguments();
if (methodTypeParameters.Length != methodParamArgs.Length) return null;
var genericMethod = m.MakeGenericMethod(methodParamArgs);
var parameters = genericMethod.GetParameters();
if (parameters.Length != types.Length) return null;
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i].ParameterType != types[i]) return null;
}
return genericMethod;
}
return null;
}).FirstOrDefault(m => m != null);
}
else
{
proxyMethod = proxyType.GetMethod(MethodName, types);
}
return proxyMethod != null;
}
private static void BuildGenericArguments(MethodInfo method, StringBuilder builder)
{
builder.Append("<");
var genericArguments = new List<string>();
foreach (var argument in method.GetGenericArguments())
{
genericArguments.Add(argument.Name);
}
builder.Append(string.Join(", ", genericArguments));
builder.Append(">");
}
/// <summary>
/// Checks whether the provided method matches the expected generic argument types.
/// </summary>
/// <param name="method"></param>
/// <param name="expectedArgumentTypes"></param>
/// <returns></returns>
public static bool ArgumentsMatch(MethodInfo method, Type[] expectedArgumentTypes)
{
bool argumentsMatch = true;
// Disabled logging to boost performance
//using (LogGroup logGroup = LogGroup.Start("Checking whether the provided arguments match those on the provided method.", LogLevel.Debug))
//{
if (method == null)
throw new ArgumentNullException("method");
if (expectedArgumentTypes == null)
throw new ArgumentNullException("expectedArgumentTypes");
// LogWriter.Debug("Method name: " + method.Name);
// LogWriter.Debug("Method parent object: " + method.DeclaringType.FullName);
Type[] argumentTypes = method.GetGenericArguments();
// LogWriter.Debug("Arguments on method: " + argumentTypes.Length);
// LogWriter.Debug("Arguments expected: " + expectedArgumentTypes);
if (argumentTypes.Length == expectedArgumentTypes.Length)
{
for (int i = 0; i < expectedArgumentTypes.Length; i++)
{
// Get the actual type of the argument
Type actualType = argumentTypes[i];
if (actualType == null)
throw new Exception("actualType == null");
if (actualType.FullName == string.Empty)
throw new Exception("actualType.FullName == String.Empty");
// LogWriter.Debug("Comparing expected argument type '" + expectedArgumentTypes[i].FullName + "' with actual type '" + actualType.FullName + "'.");
bool match = actualType.FullName == expectedArgumentTypes[i].FullName;
bool isAssignable = actualType.IsAssignableFrom(expectedArgumentTypes[i]);
// LogWriter.Debug("Match: " + match);
// LogWriter.Debug("Is assignable: " + isAssignable);
if (!(match || isAssignable))
argumentsMatch = false;
}
}
else
argumentsMatch = false;
// LogWriter.Debug("Parameters match: " + argumentsMatch.ToString());
//}
return argumentsMatch;
}
/// <summary>
/// Takes the given <paramref name="genericMethodDefinition"/> and instantiates it, substituting its generic parameter with the value
/// type of the value held by this object. The method must have exactly one generic parameter.
/// </summary>
/// <param name="genericMethodDefinition">The generic method definition to instantiate.</param>
/// <returns>
/// A closed generic instantiation of <paramref name="genericMethodDefinition"/> with this object's value type substituted for
/// the generic parameter.
/// </returns>
public MethodInfo MakeClosedGenericExecuteMethod (MethodInfo genericMethodDefinition)
{
ArgumentUtility.CheckNotNull ("genericMethodDefinition", genericMethodDefinition);
if (!genericMethodDefinition.IsGenericMethodDefinition)
throw new ArgumentException ("GenericMethodDefinition must be a generic method definition.", "genericMethodDefinition");
if (genericMethodDefinition.GetGenericArguments ().Length != 1)
throw new ArgumentException ("GenericMethodDefinition must have exactly one generic parameter.", "genericMethodDefinition");
return genericMethodDefinition.MakeGenericMethod (DataType);
}
public bool MethodEquals(MethodDefinition md, MethodInfo mi)
{
if (!MemberEquals(md, mi) || !TypeEquals(md.ReturnType, mi.ReturnType) || (int)md.Attributes != (int)mi.Attributes)
return false;
var pis = mi.GetParameters();
if (md.Parameters.Count != pis.Length)
return false;
for (int i = 0; i < pis.Length; i++)
if (!TypeEquals(md.Parameters[i].ParameterType, pis[i].ParameterType))
return false;
if (!mi.IsGenericMethod)
return md.GenericParameters.Count == 0;
if (mi.GetGenericArguments().Length != md.GenericParameters.Count)
return false;
return mi.GetGenericArguments().Length == md.GenericParameters.Count;
}
public bool InitializeProxyMethod(MethodInfo sourceMethod, Type[] types, out MethodInfo proxyMethod)
{
var proxyType = this.ProxyType;
if (types == null) throw new ArgumentOutOfRangeException("types");
var proxyTypeArgs = new List<Type>();
if (ReflectionHelper.IsGenericType(sourceMethod.DeclaringType))
{
proxyTypeArgs.AddRange(sourceMethod.DeclaringType.GetTypeInfo().GenericTypeArguments);
}
if (sourceMethod.IsGenericMethod)
{
proxyTypeArgs.AddRange(sourceMethod.GetGenericArguments());
}
var typeArrayPointer = 0;
if (proxyType.IsGenericTypeDefinition)
{
var typeArgs = new Type[proxyType.GenericTypeParameters.Length];
for (int i = 0; i < typeArgs.Length; i++)
{
typeArgs[i] = proxyTypeArgs[typeArrayPointer];
typeArrayPointer++;
}
proxyType = proxyType.MakeGenericType(typeArgs).GetTypeInfo();
}
if (proxyTypeArgs.Count == typeArrayPointer)
{
proxyMethod = proxyType.GetDeclaredMethods(MethodName).FirstOrDefault(m => CheckTypes(m.GetParameters(), types));
}
else
{
var typeArgs = new Type[proxyTypeArgs.Count - typeArrayPointer];
for (int i = 0; i < typeArgs.Length; i++)
{
typeArgs[i] = proxyTypeArgs[typeArrayPointer];
typeArrayPointer++;
}
proxyMethod = proxyType.GetDeclaredMethods(MethodName).FirstOrDefault(m =>
{
if (!m.IsGenericMethodDefinition || m.GetGenericArguments().Length != typeArgs.Length) return false;
var genericMethod = m.MakeGenericMethod(typeArgs);
return CheckTypes(genericMethod.GetParameters(), types);
});
if (proxyMethod != null)
{
proxyMethod = proxyMethod.MakeGenericMethod(typeArgs);
return true;
}
}
if (proxyMethod == null) return false;
return true;
}
/// <summary>
/// Processes the method generic parameters.
/// </summary>
/// <param name="m">The m.</param>
/// <returns></returns>
private IList <TypeModel> ProcessMethodGenericParameters(System.Reflection.MethodInfo m)
{
if (m.IsGenericMethod)
{
return(m.GetGenericArguments().Select(t => new TypeModel {
BaseType = t, Name = t.ToSafeName()
}).ToList());
}
else
{
return(default(IList <TypeModel>));
}
}
static StackObject *GetGenericArguments_9(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Reflection.MethodInfo instance_of_this_method = (System.Reflection.MethodInfo) typeof(System.Reflection.MethodInfo).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.GetGenericArguments();
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
private System.Reflection.MethodInfo ReplaceAnonymousType(System.Reflection.MethodInfo methodInfo)
{
if (methodInfo.IsGenericMethod)
{
var args =
from a in methodInfo.GetGenericArguments()
select ReplaceAnonymousType(a);
return(methodInfo.GetGenericMethodDefinition().MakeGenericMethod(args.ToArray()));
}
else
{
return(methodInfo);
}
}
private void addMethodCall(List <ParameterExpression> parameters, List <byte> result, IList <Expression> arguments, System.Reflection.MethodInfo method, Expression target)
{
result.Add((byte)ExpressionType.Call);
if (target == null)
{
serialize(Expression.Constant(null, typeof(object)), parameters, result);
}
else
{
serialize(target, parameters, result);
}
addType(result, method.DeclaringType);
addString(result, method.Name);
addInt16(result, (short)arguments.Count);
for (var i = 0; i < arguments.Count; i++)
{
serialize(arguments[i], parameters, result);
}
result.Add((byte)(method.IsConstructedGenericMethod ? 1 : 0));
if (method.IsConstructedGenericMethod)
{
var genericArguments = method.GetGenericArguments();
result.Add(checked ((byte)genericArguments.Length));
for (var i = 0; i < genericArguments.Length; i++)
{
addType(result, genericArguments[i]);
}
}
}
/// <summary>
/// Translates a SignatureType into its equivalent resolved Type by recursively substituting all generic parameter references
/// with its corresponding generic parameter definition. This is slow so MatchesExactly or MatchesParameterTypeExactly should be
/// substituted instead whenever possible. This is only used by the DefaultBinder when its fast-path checks have been exhausted and
/// it needs to call non-trivial methods like IsAssignableFrom which SignatureTypes will never support.
///
/// Because this method is used to eliminate method candidates in a GetMethod() lookup, it is entirely possible that the Type
/// might not be creatable due to conflicting generic constraints. Since this merely implies that this candidate is not
/// the method we're looking for, we return null rather than let the TypeLoadException bubble up. The DefaultBinder will catch
/// the null and continue its search for a better candidate.
/// </summary>
internal static Type TryResolveAgainstGenericMethod(this SignatureType signatureType, MethodInfo genericMethod)
{
return(signatureType.TryResolve(genericMethod.GetGenericArguments()));
}
static private IEnumerable <Instruction> Body(this MethodInfo method, byte[] buffer)
{
if (buffer == null)
{
yield break;
}
var _authority = new Authority(method);
var _stream = new MemoryStream(buffer);
var _reader = new BinaryReader(_stream);
var _code = OpCodes.Nop;
while (_stream.Position < _stream.Length)
{
var _byte = _reader.ReadByte();
if (_byte != 0xFE)
{
_code = ___MethodInfo.m_Single[_byte];
}
else
{
_byte = _reader.ReadByte();
_code = ___MethodInfo.m_Double[_byte];
}
switch (_code.OperandType)
{
case OperandType.InlineNone:
yield return(new Instruction(_code, null, null));
break;
case OperandType.ShortInlineBrTarget:
yield return(new Instruction <Label>(_code, _reader.ReadShortLabel()));
break;
case OperandType.InlineBrTarget:
yield return(new Instruction <Label>(_code, _reader.ReadLabel()));
break;
case OperandType.ShortInlineI:
yield return(new Instruction <byte>(_code, _reader.ReadByte()));
break;
case OperandType.InlineI:
yield return(new Instruction <int>(_code, _reader.ReadInt32()));
break;
case OperandType.InlineI8:
yield return(new Instruction <long>(_code, _reader.ReadInt64()));
break;
case OperandType.ShortInlineR:
yield return(new Instruction <float>(_code, _reader.ReadSingle()));
break;
case OperandType.InlineR:
yield return(new Instruction <double>(_code, _reader.ReadDouble()));
break;
case OperandType.ShortInlineVar:
yield return(new Instruction <byte>(_code, _reader.ReadByte()));
break;
case OperandType.InlineVar:
yield return(new Instruction <short>(_code, _reader.ReadInt16()));
break;
case OperandType.InlineString:
yield return(new Instruction <string>(_code, _authority.String(_reader.ReadInt32())));
break;
case OperandType.InlineSig:
yield return(new Instruction <byte[]>(_code, _authority.Signature(_reader.ReadInt32())));
break;
case OperandType.InlineField:
yield return(new Instruction <FieldInfo>(_code, _authority.Field(_reader.ReadInt32(), method.DeclaringType == null ? new Type[0] : method.DeclaringType.GetGenericArguments(), method.IsGenericMethod ? method.GetGenericArguments() : new Type[0])));
break;
case OperandType.InlineMethod:
var _method = _authority.Method(_reader.ReadInt32(), method.DeclaringType == null ? new Type[0] : method.DeclaringType.GetGenericArguments(), method.IsGenericMethod ? method.GetGenericArguments() : new Type[0]);
if (_method is ConstructorInfo)
{
yield return(new Instruction <ConstructorInfo>(_code, (ConstructorInfo)_method));
}
else
{
yield return(new Instruction <MethodInfo>(_code, (MethodInfo)_method));
}
break;
case OperandType.InlineType:
yield return(new Instruction <Type>(_code, _authority.Type(_reader.ReadInt32(), method.DeclaringType == null ? new Type[0] : method.DeclaringType.GetGenericArguments(), method.IsGenericMethod ? method.GetGenericArguments() : new Type[0])));
break;
case OperandType.InlineTok:
var _member = (MemberInfo)_authority.Member(_reader.ReadInt32(), method.DeclaringType == null ? new Type[0] : method.DeclaringType.GetGenericArguments(), method.IsGenericMethod ? method.GetGenericArguments() : new Type[0]);
if (_member is FieldInfo)
{
yield return(new Instruction <FieldInfo>(_code, (FieldInfo)_member));
}
else if (_member is ConstructorInfo)
{
yield return(new Instruction <ConstructorInfo>(_code, (ConstructorInfo)_member));
}
else if (_member is MethodInfo)
{
yield return(new Instruction <MethodInfo>(_code, (MethodInfo)_member));
}
else if (_member is Type)
{
yield return(new Instruction <Type>(_code, (Type)_member));
}
break;
case OperandType.InlineSwitch:
yield return(new Instruction <Label[]>(OpCodes.Switch, Enumerable.Range(0, Convert.ToInt32(_reader.ReadUInt32())).Select(_Iterator => _reader.ReadLabel()).ToArray()));
break;
default:
throw new NotSupportedException();
}
}
}
/// <summary>
/// Gets the full signature.
/// </summary>
/// <param name="This">This MethodInfo.</param>
/// <returns>The full signature of the method.</returns>
public static string GetFullSignature(this MethodInfo This)
{
#if NET40
Contract.Requires(This != null);
#endif
var sb = new StringBuilder();
if (This.IsPublic)
{
sb.Append("public ");
}
else if (This.IsPrivate)
{
sb.Append("private ");
}
else if (This.IsAssembly)
{
sb.Append("internal ");
}
else if (This.IsFamily)
{
sb.Append("protected ");
}
if (This.IsStatic)
{
sb.Append("static ");
}
if (This.IsFinal)
{
sb.Append("final ");
}
if (This.IsVirtual)
{
sb.Append("virtual ");
}
if (This.IsAbstract)
{
sb.Append("abstract ");
}
sb.Append(_tidyTypeName(This.ReturnType));
sb.Append(' ');
sb.Append(This.DeclaringType.ToString());
sb.Append('.');
sb.Append(This.Name);
var types = This.IsGenericMethod ? This.GetGenericArguments() : null;
if (types != null)
{
sb.Append('<');
for (var j = 0; j < types.Length; j++)
{
if (j > 0)
{
sb.Append(", ");
}
sb.Append(_tidyTypeName(types[j]));
}
sb.Append('>');
}
sb.Append('(');
var pars = This.GetParameters();
var lastI = pars.Length - 1;
for (var i = 0; i < pars.Length; i++)
{
if (i > 0)
{
sb.Append(", ");
}
var p = pars[i];
/*if (p.IsOptional)
* sb.Append("optional ");
*/
var paramType = p.ParameterType;
if (paramType.IsByRef)
{
sb.Append("ref ");
}
else if (p.IsOut)
{
sb.Append("out ");
}
if (i == lastI && paramType.IsArray)
{
sb.Append("params ");
}
sb.Append(_tidyTypeName(paramType) + ' ');
sb.Append(p.Name);
if (p.IsOptional)
{
sb.Append(" = " + (p.DefaultValue ?? "null"));
}
}
sb.Append(')');
return(sb.ToString());
}
/// <summary>
/// Return the method signature as a string.
/// </summary>
/// <param name="method">The Method</param>
/// <param name="callable">Return as an callable string(public void a(string b) would return a(b))</param>
/// <returns>Method signature</returns>
public static string GetSignature(this MethodInfo method, bool callable = false)
{
var firstParam = true;
var sigBuilder = new StringBuilder();
if (callable == false)
{
if (method.IsPublic)
{
sigBuilder.Append("public ");
}
else if (method.IsPrivate)
{
sigBuilder.Append("private ");
}
else if (method.IsAssembly)
{
sigBuilder.Append("internal ");
}
if (method.IsFamily)
{
sigBuilder.Append("protected ");
}
if (method.IsStatic)
{
sigBuilder.Append("static ");
}
sigBuilder.Append(TypeName(method.ReturnType));
sigBuilder.Append(' ');
}
sigBuilder.Append(method.Name);
// Add method generics
if (method.IsGenericMethod)
{
sigBuilder.Append("<");
foreach (var g in method.GetGenericArguments())
{
if (firstParam)
{
firstParam = false;
}
else
{
sigBuilder.Append(", ");
}
sigBuilder.Append(TypeName(g));
}
sigBuilder.Append(">");
}
sigBuilder.Append("(");
firstParam = true;
var secondParam = false;
foreach (var param in method.GetParameters())
{
if (firstParam)
{
firstParam = false;
if (method.IsDefined(typeof(System.Runtime.CompilerServices.ExtensionAttribute), false))
{
if (callable)
{
secondParam = true;
continue;
}
sigBuilder.Append("this ");
}
}
else if (secondParam == true)
{
secondParam = false;
}
else
{
sigBuilder.Append(", ");
}
if (param.ParameterType.IsByRef)
{
sigBuilder.Append("ref ");
}
else if (param.IsOut)
{
sigBuilder.Append("out ");
}
if (!callable)
{
sigBuilder.Append(TypeName(param.ParameterType));
sigBuilder.Append(' ');
}
sigBuilder.Append(param.Name);
}
sigBuilder.Append(")");
return(sigBuilder.ToString());
}
public void PrintMethod(SysRef.MethodInfo method)
{
if (method.IsStatic)
{
_builder.Append("static ");
}
var callConv = method.CallingConvention;
if ((callConv & SysRef.CallingConventions.VarArgs) == SysRef.CallingConventions.VarArgs)
{
_builder.Append("vararg ");
}
// Owner
if ((_flags & SignaturePrintingFlags.IgnoreMemberOwner) != SignaturePrintingFlags.IgnoreMemberOwner)
{
PrintType(method.DeclaringType);
_builder.Append("::");
}
// Name
PrintIdentifier(method.Name);
// Generic arguments
{
var genericArguments = method.GetGenericArguments();
if (genericArguments.Length > 0)
{
_builder.Append("<");
for (int i = 0; i < genericArguments.Length; i++)
{
if (i > 0)
{
_builder.Append(", ");
}
PrintType(genericArguments[i], false);
}
_builder.Append(">");
}
}
// Parameters
{
var parameters = method.GetParameters();
_builder.Append("(");
for (int i = 0; i < parameters.Length; i++)
{
if (i > 0)
{
_builder.Append(", ");
}
PrintType(parameters[i].ParameterType, false);
}
_builder.Append(")");
}
// Return type
_builder.Append(" : ");
PrintType(method.ReturnType, false);
}
/// <summary>
/// Translates a SignatureType into its equivalent resolved Type by recursively substituting all generic parameter references
/// with its corresponding generic parameter definition. This is slow so MatchesExactly or MatchesParameterTypeExactly should be
/// substituted instead whenever possible. This is only used by the DefaultBinder when its fast-path checks have been exhausted and
/// it needs to call non-trivial methods like IsAssignableFrom which SignatureTypes will never support.
///
/// Because this method is used to eliminate method candidates in a GetMethod() lookup, it is entirely possible that the Type
/// might not be creatable due to conflicting generic constraints. Since this merely implies that this candidate is not
/// the method we're looking for, we return null rather than let the TypeLoadException bubble up. The DefaultBinder will catch
/// the null and continue its search for a better candidate.
/// </summary>
internal static Type?TryResolveAgainstGenericMethod(this Type signatureType, MethodInfo genericMethod)
{
Debug.Assert(signatureType.IsSignatureType());
return(signatureType.TryResolve(genericMethod.GetGenericArguments()));
}
public static void GetSerializationInfo(SerializationInfo info, MethodInfo m)
{
Type[] genericArguments = m.IsConstructedGenericMethod ? m.GetGenericArguments() : null;
GetSerializationInfo(info, m.Name, m.ReflectedType, m.ToString(), m.SerializationToString(), MemberTypes.Method, genericArguments);
}
private MethodBuilder AddMethodImpl(MethodInfo mi)
{
ParameterInfo[] parameters = mi.GetParameters();
Type[] paramTypes = ParamTypes(parameters, false);
MethodBuilder mdb = _tb.DefineMethod(mi.Name, MethodAttributes.Public | MethodAttributes.Virtual, mi.ReturnType, paramTypes);
if (mi.ContainsGenericParameters)
{
Type[] ts = mi.GetGenericArguments();
string[] ss = new string[ts.Length];
for (int i = 0; i < ts.Length; i++)
{
ss[i] = ts[i].Name;
}
GenericTypeParameterBuilder[] genericParameters = mdb.DefineGenericParameters(ss);
for (int i = 0; i < genericParameters.Length; i++)
{
genericParameters[i].SetGenericParameterAttributes(ts[i].GetTypeInfo().GenericParameterAttributes);
}
}
ILGenerator il = mdb.GetILGenerator();
ParametersArray args = new ParametersArray(il, paramTypes);
// object[] args = new object[paramCount];
il.Emit(OpCodes.Nop);
GenericArray <object> argsArr = new GenericArray <object>(il, ParamTypes(parameters, true).Length);
for (int i = 0; i < parameters.Length; i++)
{
// args[i] = argi;
if (!parameters[i].IsOut)
{
argsArr.BeginSet(i);
args.Get(i);
argsArr.EndSet(parameters[i].ParameterType);
}
}
// object[] packed = new object[PackedArgs.PackedTypes.Length];
GenericArray <object> packedArr = new GenericArray <object>(il, PackedArgs.PackedTypes.Length);
// packed[PackedArgs.DispatchProxyPosition] = this;
packedArr.BeginSet(PackedArgs.DispatchProxyPosition);
il.Emit(OpCodes.Ldarg_0);
packedArr.EndSet(typeof(DispatchProxy));
// packed[PackedArgs.DeclaringTypePosition] = typeof(iface);
MethodInfo Type_GetTypeFromHandle = typeof(Type).GetRuntimeMethod("GetTypeFromHandle", new Type[] { typeof(RuntimeTypeHandle) });
int methodToken;
Type declaringType;
_assembly.GetTokenForMethod(mi, out declaringType, out methodToken);
packedArr.BeginSet(PackedArgs.DeclaringTypePosition);
il.Emit(OpCodes.Ldtoken, declaringType);
il.Emit(OpCodes.Call, Type_GetTypeFromHandle);
packedArr.EndSet(typeof(object));
// packed[PackedArgs.MethodTokenPosition] = iface method token;
packedArr.BeginSet(PackedArgs.MethodTokenPosition);
il.Emit(OpCodes.Ldc_I4, methodToken);
packedArr.EndSet(typeof(Int32));
// packed[PackedArgs.ArgsPosition] = args;
packedArr.BeginSet(PackedArgs.ArgsPosition);
argsArr.Load();
packedArr.EndSet(typeof(object[]));
// packed[PackedArgs.GenericTypesPosition] = mi.GetGenericArguments();
if (mi.ContainsGenericParameters)
{
packedArr.BeginSet(PackedArgs.GenericTypesPosition);
Type[] genericTypes = mi.GetGenericArguments();
GenericArray <Type> typeArr = new GenericArray <Type>(il, genericTypes.Length);
for (int i = 0; i < genericTypes.Length; ++i)
{
typeArr.BeginSet(i);
il.Emit(OpCodes.Ldtoken, genericTypes[i]);
il.Emit(OpCodes.Call, Type_GetTypeFromHandle);
typeArr.EndSet(typeof(Type));
}
typeArr.Load();
packedArr.EndSet(typeof(Type[]));
}
// Call static DispatchProxyHelper.Invoke(object[])
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, _fields[InvokeActionFieldAndCtorParameterIndex]); // delegate
packedArr.Load();
il.Emit(OpCodes.Call, s_delegateInvoke);
for (int i = 0; i < parameters.Length; i++)
{
if (parameters[i].ParameterType.IsByRef)
{
args.BeginSet(i);
argsArr.Get(i);
args.EndSet(i, typeof(object));
}
}
if (mi.ReturnType != typeof(void))
{
packedArr.Get(PackedArgs.ReturnValuePosition);
Convert(il, typeof(object), mi.ReturnType, false);
}
il.Emit(OpCodes.Ret);
_tb.DefineMethodOverride(mdb, mi);
return(mdb);
}
