/// <summary> /// Weaves the specified module definition. /// </summary> /// <param name="moduleDefinition">The module definition.</param> public bool Weave(ModuleDefMD moduleDefinition) { var auditTimer = new AuditTimer(); try { // sanity check auditTimer.NewZone("Types import"); // context var context = CreateWeavingContext(moduleDefinition); if (context.AdviceInterfaceType == null) { Logging.WriteWarning("IAdvice interface not found here (not referenced means not used), exiting"); return(false); } // runtime check auditTimer.NewZone("Runtime check"); var targetFramework = GetTargetFramework(moduleDefinition); InjectAsPrivate = targetFramework.Silverlight == null && targetFramework.WindowsPhone == null; // weave methods (they can be property-related, too) auditTimer.NewZone("Weavable methods detection"); Func <MarkedNode, bool> isWeavable = n => IsWeavable(n) && !IsFromComputerGeneratedType(n); var weavingAdvicesMethods = GetMarkedMethods(moduleDefinition, context.WeavingAdviceInterfaceType, context).Where(isWeavable).ToArray(); var weavableMethods = GetMarkedMethods(moduleDefinition, context.AdviceInterfaceType, context).Where(isWeavable).ToArray(); auditTimer.NewZone("Abstract targets"); var generatedFieldsToBeRemoved = new List <FieldDef>(); var methodsWithAbstractTarget = weavableMethods.Where(m => m.AbstractTarget).ToArray(); if (methodsWithAbstractTarget.Length > 0) { generatedFieldsToBeRemoved.AddRange(GetRemovableFields(methodsWithAbstractTarget, context)); foreach (var fieldReference in generatedFieldsToBeRemoved) { Logging.WriteDebug("Field {0} to be removed", fieldReference.FullName); } } auditTimer.NewZone("Methods weaving advice"); weavingAdvicesMethods.ForAll(i => RunWeavingAdvices(i, context)); auditTimer.NewZone("Methods weaving"); weavableMethods.ForAll(m => WeaveMethod(moduleDefinition, m, context)); auditTimer.NewZone("Weavable interfaces detection"); var weavableInterfaces = GetAdviceHandledInterfaces(moduleDefinition).ToArray(); auditTimer.NewZone("Interface methods weaving"); weavableInterfaces.ForAll(i => WeaveInterface(moduleDefinition, i, context)); // and then, the info advices auditTimer.NewZone("Info advices weaving"); var infoAdviceInterface = TypeResolver.Resolve(moduleDefinition, typeof(IInfoAdvice)); moduleDefinition.GetTypes().ForAll(t => WeaveInfoAdvices(moduleDefinition, t, infoAdviceInterface, context)); auditTimer.NewZone("Abstract targets cleanup"); foreach (var generatedFieldToBeRemoved in generatedFieldsToBeRemoved) { generatedFieldToBeRemoved.DeclaringType.Fields.Remove(generatedFieldToBeRemoved); } auditTimer.LastZone(); var report = auditTimer.GetReport(); var maxLength = report.Keys.Max(k => k.Length); Logging.WriteDebug("--- Timings --------------------------"); foreach (var reportPart in report) { Logging.WriteDebug("{0} : {1}ms", reportPart.Key.PadRight(maxLength), (int)reportPart.Value.TotalMilliseconds); } Logging.WriteDebug("--------------------------------------"); Logging.Write("MrAdvice {3} weaved module '{0}' (targeting framework {2}) in {1}ms", moduleDefinition.Assembly.FullName, (int)report.Sum(r => r.Value.TotalMilliseconds), targetFramework.ToString(), Product.Version); return(true); } catch (Exception e) { Logging.WriteError("Internal error during {0}: {1}", auditTimer.CurrentZoneName, e); Logging.WriteError("Please complain, whine, cry, yell at https://github.com/ArxOne/MrAdvice/issues/new"); return(false); } }
/// <summary> /// Gets the advice handled interfaces. /// This is done by analyzing calls in all methods from module /// </summary> /// <param name="moduleDefinition">The module definition.</param> /// <returns></returns> private IEnumerable <TypeDef> GetAdviceHandledInterfaces(ModuleDef moduleDefinition) { // the first method to look for in the final AdviceExtensions.Handle<>() method var adviceExtensionsType = TypeResolver.Resolve(moduleDefinition, typeof(AdviceExtensions)); var adviceHandleMethod = adviceExtensionsType.Methods.Single(m => m.IsPublic && m.HasGenericParameters && m.Name == nameof(AdviceExtensions.Handle)); var methodsSearched = new HashSet <MethodDef>(new MethodReferenceComparer()) { adviceHandleMethod }; var foundHandledInterfaces = new HashSet <ITypeDefOrRef>(new TypeReferenceComparer()); var methodsToSearch = new List <Tuple <MethodDef, int> > { Tuple.Create(adviceHandleMethod, 0) }; while (methodsToSearch.Count > 0) { var methodToSearch = methodsToSearch[0]; methodsToSearch.RemoveAt(0); foreach (var t in GetAdviceHandledInterfaces(moduleDefinition, methodToSearch.Item1, methodToSearch.Item2)) { // if the supposed interface type itself is a generic parameter // this means that the calling method (Item2) is itself a generic parameter // and we have to lookup for calls to this method if (t.Item1.ContainsGenericParameter) { if (!methodsSearched.Contains(t.Item2)) { // ReSharper disable once AccessToForEachVariableInClosure var parameterIndex = t.Item2.GenericParameters.IndexOf(p => p.Name == t.Item1.TypeName); methodsSearched.Add(t.Item2); methodsToSearch.Add(Tuple.Create(t.Item2, parameterIndex)); Logging.WriteDebug("Now looking for references to '{0} [{1}]'", methodToSearch.Item1.ToString(), parameterIndex); } } // only interfaces are processed by now else { var interfaceDef = t.Item1 as TypeDef; if (interfaceDef == null) { if (t.Item1 is TypeRef interfaceRef) { interfaceDef = TypeResolver.Resolve(interfaceRef); } } if (interfaceDef == null) { Logging.WriteError("Can not identify {0} as valid weavable interface. If you feel this is unfair --> https://github.com/ArxOne/MrAdvice/issues/new", t.Item1.ToString()); continue; } if (interfaceDef.IsInterface) { // otherwise, this is a direct call, keep the injected interface name if (!foundHandledInterfaces.Contains(t.Item1)) { foundHandledInterfaces.Add(t.Item1); yield return(interfaceDef); } } else { Logging.WriteError("Only interfaces can be weaved with Handle<>() extension method and {0} it not an interface (but I'm glad you asked)", interfaceDef.FullName); } } } } }
/// <summary> /// Writes the pointcut body. /// </summary> /// <param name="method">The method.</param> /// <param name="innerMethod">The inner method.</param> /// <param name="abstractedTarget">if set to <c>true</c> [abstracted target].</param> /// <exception cref="System.InvalidOperationException"> /// </exception> private void WritePointcutBody(MethodDefinition method, MethodDefinition innerMethod, bool abstractedTarget) { var moduleDefinition = method.Module; // now empty the old one and make it call the inner method... if (method.Body == null) { method.Body = new MethodBody(method); } method.Body.InitLocals = true; method.Body.Instructions.Clear(); method.Body.Variables.Clear(); method.Body.ExceptionHandlers.Clear(); var instructions = new Instructions(method.Body.Instructions, method.Module); var isStatic = method.Attributes.HasFlag(MethodAttributes.Static); // parameters VariableDefinition parametersVariable = null; if (method.Parameters.Count > 0) { parametersVariable = new VariableDefinition("parameters", moduleDefinition.SafeImport(typeof(object[]))); method.Body.Variables.Add(parametersVariable); instructions.EmitLdc(method.Parameters.Count); instructions.Emit(OpCodes.Newarr, moduleDefinition.SafeImport(typeof(object))); instructions.EmitStloc(parametersVariable); // setups parameters array for (int parameterIndex = 0; parameterIndex < method.Parameters.Count; parameterIndex++) { var parameter = method.Parameters[parameterIndex]; // we don't care about output parameters if (!parameter.IsOut) { instructions.EmitLdloc(parametersVariable); // array instructions.EmitLdc(parameterIndex); // array index instructions.EmitLdarg(parameter); // loads given parameter... var parameterType = parameter.ParameterType; if (parameter.ParameterType.IsByReference) // ...if ref, loads it as referenced value { parameterType = parameter.ParameterType.GetElementType(); instructions.EmitLdind(parameterType); } instructions.EmitBoxIfNecessary(parameterType); // ... and boxes it instructions.Emit(OpCodes.Stelem_Ref); } } } // if method has generic parameters, we also pass them to Proceed method VariableDefinition genericParametersVariable = null; // on static methods from genetic type, we also record the generic parameters type //var typeGenericParametersCount = isStatic ? method.DeclaringType.GenericParameters.Count : 0; var typeGenericParametersCount = method.DeclaringType.GenericParameters.Count; if (typeGenericParametersCount > 0 || method.HasGenericParameters) { //IL_0001: ldtoken !!T //IL_0006: call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) genericParametersVariable = new VariableDefinition("genericParameters", moduleDefinition.SafeImport(typeof(Type[]))); method.Body.Variables.Add(genericParametersVariable); instructions.EmitLdc(typeGenericParametersCount + method.GenericParameters.Count); instructions.Emit(OpCodes.Newarr, moduleDefinition.SafeImport(typeof(Type))); instructions.EmitStloc(genericParametersVariable); var genericParameters = new List <GenericParameter>(); for (int typeGenericParameterIndex = 0; typeGenericParameterIndex < typeGenericParametersCount; typeGenericParameterIndex++) { genericParameters.Add(method.DeclaringType.GenericParameters[typeGenericParameterIndex]); } genericParameters.AddRange(method.GenericParameters); for (int genericParameterIndex = 0; genericParameterIndex < genericParameters.Count; genericParameterIndex++) { instructions.EmitLdloc(genericParametersVariable); // array instructions.EmitLdc(genericParameterIndex); // array index instructions.Emit(OpCodes.Ldtoken, genericParameters[genericParameterIndex]); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed instructions.Emit(OpCodes.Call, ReflectionUtility.GetMethodInfo(() => Type.GetTypeFromHandle(new RuntimeTypeHandle()))); instructions.Emit(OpCodes.Stelem_Ref); } } // null or instance instructions.Emit(isStatic ? OpCodes.Ldnull : OpCodes.Ldarg_0); // to fix peverify 0x80131854 if (!isStatic && method.IsConstructor) { instructions.Emit(OpCodes.Castclass, typeof(object)); } // parameters if (parametersVariable != null) { instructions.EmitLdloc(parametersVariable); } else { instructions.Emit(OpCodes.Ldnull); } // methods... // ... target // ReSharper disable once ReturnValueOfPureMethodIsNotUsed instructions.Emit(OpCodes.Call, ReflectionUtility.GetMethodInfo(() => MethodBase.GetCurrentMethod())); // ... inner... If provided if (innerMethod != null) { // if type is generic, this is a bit more complex, because we need to pass the type if (method.DeclaringType.HasGenericParameters) { // we want to reuse the MethodBase.GetCurrentMethod() result // so it is stored into a variable, whose property DeclaringType is invoked later var currentMethodVariable = new VariableDefinition("currentMethod", moduleDefinition.SafeImport(typeof(MethodBase))); method.Body.Variables.Add(currentMethodVariable); instructions.EmitStloc(currentMethodVariable); instructions.EmitLdloc(currentMethodVariable); instructions.Emit(OpCodes.Ldtoken, innerMethod); instructions.EmitLdloc(currentMethodVariable); instructions.Emit(OpCodes.Callvirt, ReflectionUtility.GetMethodInfo((Type t) => t.DeclaringType)); instructions.Emit(OpCodes.Callvirt, ReflectionUtility.GetMethodInfo((Type t) => t.TypeHandle)); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed instructions.Emit(OpCodes.Call, ReflectionUtility.GetMethodInfo(() => MethodBase.GetMethodFromHandle(new RuntimeMethodHandle(), new RuntimeTypeHandle()))); } else { instructions.Emit(OpCodes.Ldtoken, innerMethod); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed instructions.Emit(OpCodes.Call, ReflectionUtility.GetMethodInfo(() => MethodBase.GetMethodFromHandle(new RuntimeMethodHandle()))); } } else { instructions.Emit(OpCodes.Ldnull); } // abstracted target instructions.Emit(abstractedTarget ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0); if (genericParametersVariable != null) { instructions.EmitLdloc(genericParametersVariable); } else { instructions.Emit(OpCodes.Ldnull); } // invoke the method var invocationType = TypeResolver.Resolve(moduleDefinition, typeof(Invocation)); if (invocationType == null) { throw new InvalidOperationException(); } var proceedMethodReference = invocationType.GetMethods().SingleOrDefault(m => m.IsStatic && m.Name == nameof(Invocation.ProceedAdvice)); if (proceedMethodReference == null) { throw new InvalidOperationException(); } var proceedMethod = moduleDefinition.SafeImport(proceedMethodReference); instructions.Emit(OpCodes.Call, proceedMethod); // get return value if (!method.ReturnType.SafeEquivalent(moduleDefinition.SafeImport(typeof(void)))) { instructions.EmitUnboxOrCastIfNecessary(method.ReturnType); } else { instructions.Emit(OpCodes.Pop); // if no return type, ignore Proceed() result } // loads back out/ref parameters for (int parameterIndex = 0; parameterIndex < method.Parameters.Count; parameterIndex++) { var parameter = method.Parameters[parameterIndex]; if (parameter.ParameterType.IsByReference) { instructions.EmitLdarg(parameter); // loads given parameter (it is a ref) instructions.EmitLdloc(parametersVariable); // array instructions.EmitLdc(parameterIndex); // array index instructions.Emit(OpCodes.Ldelem_Ref); // now we have boxed out/ref value var parameterElementType = parameter.ParameterType.GetElementType(); if (parameterElementType.HasGenericParameters) // a generic type requires the correct inner type { var referenceParameterType = (ByReferenceType)parameter.ParameterType; parameterElementType = (GenericInstanceType)referenceParameterType.ElementType; } instructions.EmitUnboxOrCastIfNecessary(parameterElementType); instructions.EmitStind(parameterElementType); // result is stored in ref parameter } } // and return instructions.Emit(OpCodes.Ret); }
/// <summary> /// Weaves the interface. /// What we do here is: /// - creating a class (wich is named after the interface name) /// - this class implements all interface members /// - all members invoke Invocation.ProcessInterfaceMethod /// </summary> /// <param name="moduleDefinition">The module definition.</param> /// <param name="interfaceType">Type of the interface.</param> private void WeaveInterface(ModuleDefinition moduleDefinition, TypeReference interfaceType) { Logger.WriteDebug("Weaving interface '{0}'", interfaceType.FullName); TypeDefinition implementationType; TypeDefinition advisedInterfaceType; TypeDefinition interfaceTypeDefinition; lock (moduleDefinition) { // ensure we're creating the interface only once var implementationTypeName = GetImplementationTypeName(interfaceType.Name); var implementationTypeNamespace = interfaceType.Namespace; if (moduleDefinition.GetTypes().Any(t => t.Namespace == implementationTypeNamespace && t.Name == implementationTypeName)) { return; } // now, create the implementation type interfaceTypeDefinition = interfaceType.Resolve(); var typeAttributes = (InjectAsPrivate ? TypeAttributes.NotPublic : TypeAttributes.Public) | TypeAttributes.Class | TypeAttributes.BeforeFieldInit; advisedInterfaceType = TypeResolver.Resolve(moduleDefinition, typeof(AdvisedInterface)); var advisedInterfaceTypeReference = moduleDefinition.SafeImport(advisedInterfaceType); implementationType = new TypeDefinition(implementationTypeNamespace, implementationTypeName, typeAttributes, advisedInterfaceTypeReference); lock (moduleDefinition) moduleDefinition.Types.Add(implementationType); } implementationType.Interfaces.Add(interfaceType); // create empty .ctor. This .NET mofo wants it! var baseEmptyConstructor = moduleDefinition.SafeImport(advisedInterfaceType.Resolve().GetConstructors().Single()); const MethodAttributes ctorAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName; var method = new MethodDefinition(".ctor", ctorAttributes, moduleDefinition.TypeSystem.Void); method.Body.Instructions.Add(Instruction.Create(OpCodes.Ldarg_0)); method.Body.Instructions.Add(Instruction.Create(OpCodes.Call, baseEmptyConstructor)); method.Body.Instructions.Add(Instruction.Create(OpCodes.Ret)); implementationType.Methods.Add(method); // create implementation methods foreach (var interfaceMethod in interfaceTypeDefinition.GetMethods().Where(m => !m.IsSpecialName)) { WeaveInterfaceMethod(interfaceMethod, implementationType, true); } // create implementation properties foreach (var interfaceProperty in interfaceTypeDefinition.Properties) { var implementationProperty = new PropertyDefinition(interfaceProperty.Name, PropertyAttributes.None, interfaceProperty.PropertyType); implementationType.Properties.Add(implementationProperty); if (interfaceProperty.GetMethod != null) { implementationProperty.GetMethod = WeaveInterfaceMethod(interfaceProperty.GetMethod, implementationType, InjectAsPrivate); } if (interfaceProperty.SetMethod != null) { implementationProperty.SetMethod = WeaveInterfaceMethod(interfaceProperty.SetMethod, implementationType, InjectAsPrivate); } } // create implementation events foreach (var interfaceEvent in interfaceTypeDefinition.Events) { var implementationEvent = new EventDefinition(interfaceEvent.Name, EventAttributes.None, moduleDefinition.SafeImport(interfaceEvent.EventType)); implementationType.Events.Add(implementationEvent); if (interfaceEvent.AddMethod != null) { implementationEvent.AddMethod = WeaveInterfaceMethod(interfaceEvent.AddMethod, implementationType, InjectAsPrivate); } if (interfaceEvent.RemoveMethod != null) { implementationEvent.RemoveMethod = WeaveInterfaceMethod(interfaceEvent.RemoveMethod, implementationType, InjectAsPrivate); } } }
/// <summary> /// Initializes a new instance of the <see cref="WeaverMethodWeavingContext" /> class. /// </summary> /// <param name="typeDefinition">The type definition (type being built).</param> /// <param name="type">The type (original type).</param> /// <param name="targetMethodName">Name of the target method.</param> /// <param name="context">The context.</param> /// <param name="typeResolver">The type resolver.</param> /// <param name="logging">The logging.</param> public WeaverMethodWeavingContext(TypeDef typeDefinition, Type type, string targetMethodName, WeavingContext context, TypeResolver typeResolver, ILogging logging) : base(type, targetMethodName) { _typeDefinition = typeDefinition; _context = context; _typeResolver = typeResolver; _logging = logging; }