static InitializeCallTests() { testResult = WeavingHelper.CreateIsolatedAssemblyCopy("AssemblyToProcess.dll", "<Costura />", new[] { "AssemblyToReference.dll", "AssemblyToReferencePreEmbedded.dll", "ExeToReference.exe" }, "InitializeCall"); }
static ReferenceCasingTests() { testResult = WeavingHelper.CreateIsolatedAssemblyCopy("AssemblyToProcess.dll", "<Costura IncludeAssemblies='assemblytoreference|exetoreference' />", new[] { "AssemblyToReference.dll", "AssemblyToReferencePreEmbedded.dll", "ExeToReference.exe" }, "InitializeCall"); }
static InitializeCallWithoutModuleInitTest() { testResult = WeavingHelper.CreateIsolatedAssemblyCopy("AssemblyToProcess.dll", "<Costura LoadAtModuleInit='false' />", new[] { "AssemblyToReference.dll", "AssemblyToReferencePreEmbedded.dll", "ExeToReference.exe" }, "InitializeCallWithoutModuleInit"); }
public void FailsToWeave() { Assert.Throws <WeavingException>(() => WeavingHelper.CreateIsolatedAssemblyCopy("AssemblyWithoutInitialize.dll", "<Costura LoadAtModuleInit='false' />", new[] { "AssemblyToReference.dll", "AssemblyToReferencePreEmbedded.dll", "ExeToReference.exe" }, "NoInitialize")); }
private Instruction EmitInitializeCall(ProcessorContext context, ILProcessor il) { var initializedType = type.HasGenericParameters ? WeavingHelper.CreateGenericInstance(type) : type; var start = il.Create(OpCodes.Ldarg_0); il.Append(start); il.Emit(OpCodes.Ldtoken, initializedType); il.Emit(OpCodes.Call, context.References.TypeGetTypeFromHandle); il.Emit(OpCodes.Call, context.References.PersistentInitialize); return(start); }
public void ThrowsForMissingReference() { // Note: this will throw WeavingException because References is null, but should actually // log an error about the missing assembly Assert.Throws <WeavingException>(() => { WeavingHelper.CreateIsolatedAssemblyCopy("AssemblyToProcess.dll", "<Costura IncludeAssemblies='AssemblyToReference|AssemblyToReferencePreEmbedded|ExeToReference|MissingAssembly' />", new[] { "AssemblyToReference.dll", "AssemblyToReferencePreEmbedded.dll", "ExeToReference.exe" }, "InitializeCall"); }); }
static CultureResourceTests() { testResult = WeavingHelper.CreateIsolatedAssemblyCopy("ExeToProcess.exe", "<Costura />", new[] { "AssemblyToReference.dll", "de\\AssemblyToReference.resources.dll", "fr\\AssemblyToReference.resources.dll", "AssemblyToReferencePreEmbedded.dll", "ExeToReference.exe" }, "Culture"); }
public void WeavesWildcards() { var wildcardWeave = WeavingHelper.CreateIsolatedAssemblyCopy("ExeToProcess.exe", "<Costura IncludeAssemblies=\"AssemblyToReference*\"/>", new[] { "AssemblyToReference.dll", "AssemblyToReferenceMixed.dll" }, "WildcardWeave"); var referencedAssemblies = wildcardWeave.Assembly.GetReferencedAssemblies().Select(x => x.Name).ToList(); Assert.Contains("AssemblyToReference", referencedAssemblies); Assert.Contains("AssemblyToReferencePreEmbedded", referencedAssemblies); var instance = wildcardWeave.GetInstance("ClassToTest"); Assert.AreEqual("Hello", instance.Simple()); Assert.AreEqual("Hello", instance.SimplePreEmbed()); }
private MethodDefinition DefineConstructor(ProcessorContext context) { var baseConstructor = GetBaseConstructor(context); var method = new MethodDefinition(WellKnown.Constructor, ConstructorAttributes, voidType) { HasThis = true }; DefineParameters(method); WeavingHelper.MarkAsCompilerGenerated(context, method); var il = method.Body.GetILProcessor(); WeavingHelper.EmitLoadArguments(il, signature.Length + 1); il.Emit(OpCodes.Call, baseConstructor); il.Emit(OpCodes.Ret); targetType.Methods.Add(method); return(method); }
public LoggingImplementationTypeBuilder( ModuleDeclaration module ) { this.module = module; this.categoryFields = new Dictionary<string, FieldDefDeclaration>(); this.wrapperMethods = new Dictionary<IMethod, MethodDefDeclaration>(); this.stringFormatArrayMethod = module.FindMethod( module.Cache.GetIntrinsic( IntrinsicType.String ), "Format", method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is( method.Parameters[0].ParameterType, IntrinsicType.String ) && method.Parameters[1].ParameterType.BelongsToClassification( TypeClassifications.Array ) ); this.traceWriteLineMethod = module.FindMethod( module.Cache.GetType( typeof(System.Diagnostics.Trace) ), "WriteLine", method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is( method.Parameters[0].ParameterType, IntrinsicType.String ) ); this.weavingHelper = new WeavingHelper( module ); this.implementationType = this.CreateContainingType(); this.isLoggingField = this.CreateIsLoggingField(); }
public LoggingImplementationTypeBuilder(ModuleDeclaration module) { this.module = module; this.categoryFields = new Dictionary <string, FieldDefDeclaration>(); this.wrapperMethods = new Dictionary <IMethod, MethodDefDeclaration>(); this.stringFormatArrayMethod = module.FindMethod(module.Cache.GetIntrinsic(IntrinsicType.String), "Format", method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && method.Parameters[1].ParameterType.BelongsToClassification(TypeClassifications.Array)); this.traceWriteLineMethod = module.FindMethod(module.Cache.GetType(typeof(System.Diagnostics.Trace)), "WriteLine", method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String)); this.weavingHelper = new WeavingHelper(module); this.implementationType = this.CreateContainingType(); this.isLoggingField = this.CreateIsLoggingField(); }
private Tuple <Instruction, Instruction> EmitExceptionHandler(ProcessorContext context, ILProcessor il, TypeReference exceptionType) { var initializedType = type.HasGenericParameters ? WeavingHelper.CreateGenericInstance(type) : type; var variables = constructor.Body.Variables; var instructions = constructor.Body.Instructions; var variableIndex = variables.Count; variables.Add(new VariableDefinition(exceptionType)); il.Emit(OpCodes.Stloc, variableIndex); var start = instructions[instructions.Count - 1]; il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldtoken, initializedType); il.Emit(OpCodes.Call, context.References.TypeGetTypeFromHandle); il.Emit(OpCodes.Ldloc, variableIndex); il.Emit(OpCodes.Call, context.References.PersistentInitializationError); il.Emit(OpCodes.Rethrow); il.Emit(OpCodes.Nop); var end = instructions[instructions.Count - 1]; return(Tuple.Create(start, end)); }
private void DefineFactoryMethod(ProcessorContext context, MethodReference constructor) { var returnType = (TypeReference)targetType; if (targetType.HasGenericParameters) { returnType = WeavingHelper.CreateGenericInstance(targetType); constructor = new MethodReference(WellKnown.Constructor, voidType, returnType) { HasThis = true }; DefineParameters(constructor); } var method = new MethodDefinition(WellKnown.FactoryMethod, FactoryMethodAttributes, returnType); DefineParameters(method); WeavingHelper.MarkAsCompilerGenerated(context, method); var il = method.Body.GetILProcessor(); WeavingHelper.EmitLoadArguments(il, signature.Length); il.Emit(OpCodes.Newobj, constructor); il.Emit(OpCodes.Ret); targetType.Methods.Add(method); }
public static void Get_MethodInfo(this InstructionWriter writer, IMethod method, WeavingHelper weavingHelper) { writer.Get_RuntimeMethod(method, weavingHelper); writer.Cast_ToType(method.Module.FindType(typeof(MethodInfo))); }
static TempFileTests() { testResult = WeavingHelper.CreateIsolatedAssemblyCopy("ExeToProcess.exe", "<Costura CreateTemporaryAssemblies='true' />", new[] { "AssemblyToReference.dll", "AssemblyToReferencePreEmbedded.dll", "ExeToReference.exe" }, "TempFile"); }
public static void ImplementRemoveOn( this EventDeclaration theEvent, TypeDefDeclaration type, IField field, WeavingHelper weavingHelper = null, MethodAttributes methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.NewSlot | MethodAttributes.SpecialName) { var module = type.Module; weavingHelper = weavingHelper ?? new WeavingHelper(module); var pEWeavingHelper = module.Cache.GetItem(() => new PostEdgeWeaverAssets(module)); var method = new MethodDefDeclaration { Attributes = methodAttributes, Name = "remove_" + theEvent.Name, CallingConvention = CallingConvention.HasThis }; type.Methods.Add(method); weavingHelper.AddCompilerGeneratedAttribute(method.CustomAttributes); var parameter = new ParameterDeclaration { Name = "value", ParameterType = theEvent.EventType, }; method.Parameters.Add(parameter); var methodBody = new MethodBodyDeclaration(); methodBody.EnsureWritableLocalVariables(); var instructionBlock = methodBody.CreateInstructionBlock(); var initSequence = methodBody.CreateInstructionSequence(); var loopSequence = methodBody.CreateInstructionSequence(); var endSequence = methodBody.CreateInstructionSequence(); instructionBlock.AddInstructionSequence(initSequence, NodePosition.After, null); instructionBlock.AddInstructionSequence(loopSequence, NodePosition.After, initSequence); instructionBlock.AddInstructionSequence(endSequence, NodePosition.After, loopSequence); methodBody.RootInstructionBlock = instructionBlock; method.MethodBody = methodBody; methodBody.CreateLocalVariable(theEvent.EventType); methodBody.CreateLocalVariable(theEvent.EventType); methodBody.CreateLocalVariable(theEvent.EventType); methodBody.CreateLocalVariable(module.Cache.GetIntrinsic(typeof(bool))); var writer = new InstructionWriter(); //Initialize writer.AttachInstructionSequence(initSequence); //PropertyChangedHandler handler = this.PropertyChanged writer.EmitInstruction(OpCodeNumber.Ldarg_0); //Get the this pointer writer.EmitInstructionField(OpCodeNumber.Ldfld, field); //Get the event's field writer.EmitInstruction(OpCodeNumber.Stloc_0); //store into the first local variable writer.DetachInstructionSequence(); //Loop //do { writer.AttachInstructionSequence(loopSequence); //PropertyChangedHandler handler2 = handler; writer.EmitInstruction(OpCodeNumber.Ldloc_0); writer.EmitInstruction(OpCodeNumber.Stloc_1); //PropertyChangedHandler handler3 = System.Delegate.Remove(handler2, value) writer.EmitInstruction(OpCodeNumber.Ldloc_1); writer.EmitInstruction(OpCodeNumber.Ldarg_1); writer.EmitInstructionMethod(OpCodeNumber.Call, pEWeavingHelper.DelegateRemoveMethod); writer.EmitInstructionType(OpCodeNumber.Castclass, theEvent.EventType); writer.EmitInstruction(OpCodeNumber.Stloc_2); //handler = System.Threading.Interlocked.CompareExchnage<PropertyChangedEventHandler>(ref this.PropertyChtyChanged, handler3, handler2); var compareExchangeMethodT = pEWeavingHelper.CompareExchangeMethod; var compareExchangeMethod = compareExchangeMethodT.GetGenericInstance(module, theEvent.EventType); writer.EmitInstruction(OpCodeNumber.Ldarg_0); //Load this writer.EmitInstructionField(OpCodeNumber.Ldflda, field); writer.EmitInstruction(OpCodeNumber.Ldloc_2); writer.EmitInstruction(OpCodeNumber.Ldloc_1); writer.EmitInstructionMethod(OpCodeNumber.Call, compareExchangeMethod); writer.EmitInstruction(OpCodeNumber.Stloc_0); //flag = handler != handler2; writer.EmitInstruction(OpCodeNumber.Ldloc_0); writer.EmitInstruction(OpCodeNumber.Ldloc_1); writer.EmitInstruction(OpCodeNumber.Ceq); writer.EmitInstruction(OpCodeNumber.Ldc_I4_0); writer.EmitInstruction(OpCodeNumber.Ceq); writer.EmitInstruction(OpCodeNumber.Stloc_3); //} while (flag); writer.EmitInstruction(OpCodeNumber.Ldloc_3); writer.EmitBranchingInstruction(OpCodeNumber.Brtrue_S, loopSequence); writer.DetachInstructionSequence(); //End writer.AttachInstructionSequence(endSequence); writer.EmitInstruction(OpCodeNumber.Ret); //Exit the method writer.DetachInstructionSequence(); theEvent.Members.Add(new MethodSemanticDeclaration(MethodSemantics.RemoveOn, method)); }
static MixedAndNativeTests() { testResult = WeavingHelper.CreateIsolatedAssemblyCopy("ExeToProcessWithNative.exe", "<Costura Unmanaged32Assemblies='AssemblyToReferenceMixed' />", new[] { "AssemblyToReferenceMixed.dll" }, "MixedAndNative"); }
public static void Get_RuntimeType(this InstructionWriter instructionWriter, ITypeSignature type, WeavingHelper weavingHelper) { weavingHelper.GetRuntimeType(type, instructionWriter); }
public LoggingImplementationTypeBuilder(ModuleDeclaration module) { this.module = module; this.weavingHelper = new WeavingHelper(module); this.containingType = this.CreateContainingType(); }
public static void Get_RuntimeMethod(this InstructionWriter instructionWriter, IMethod method, WeavingHelper weavingHelper) { var module = method.Module; if (!method.IsGenericDefinition && !method.DeclaringType.IsGenericDefinition) { instructionWriter.EmitInstructionMethod(OpCodeNumber.Ldtoken, method); instructionWriter.EmitInstructionMethod(OpCodeNumber.Call, module.Cache.GetItem(module.Cache.MethodBaseGetMethodFromHandle)); } else { instructionWriter.EmitInstructionMethod(OpCodeNumber.Ldtoken, method.EnsureTypeQualifiedMethod(module)); instructionWriter.EmitInstructionType(OpCodeNumber.Ldtoken, method.DeclaringType.GetTypeDefinition().GetCanonicalGenericInstance()); instructionWriter.EmitInstructionMethod(OpCodeNumber.Call, module.Cache.GetItem(module.Cache.MethodBaseGetMethodFromHandle2)); } }
private void InspectProperties(ProcessorContext context, TypeInfo type) { foreach (var property in type.Definition.Properties) { var propertyInfo = new PropertyInfo(type, property); // only indexers has parameters and we skip them if (propertyInfo.AnyAccessor == null || property.HasParameters) { continue; } propertyInfo.IsAutomatic = autoPropertyChecker.Invoke(type.Definition, property); propertyInfo.IsPersistent = propertyInfo.IsInstance && property.HasAttribute(WellKnown.FieldAttribute); propertyInfo.IsKey = propertyInfo.IsPersistent && property.HasAttribute(WellKnown.KeyAttribute); type.Properties.Add(propertyInfo.Name, propertyInfo); } var baseType = type.BaseType; if (baseType != null) { foreach (var property in type.Properties.Values) { var baseProperty = baseType.FindProperty(property.Name); if (baseProperty == null) { continue; } property.BaseProperty = baseProperty; var thisAccessor = property.AnyAccessor; var baseAccessor = baseProperty.AnyAccessor; if (baseAccessor.IsVirtual && thisAccessor.IsVirtual && !thisAccessor.IsNewSlot) { property.IsOverride = true; InheritPersistence(property, baseProperty); } else { property.IsNew = true; var persistentBase = property.FindBase(p => p.IsPersistent); if (persistentBase != null) { property.PersistentName = WeavingHelper.BuildComplexPersistentName(type, property); } } } } var propertiesToImplement = new HashSet <PropertyInfo>(type.Interfaces.SelectMany(i => i.Properties.Values)); // Exclude explicit implementations foreach (var property in type.Properties.Values) { var implementedAccessor = property.AnyAccessor.Overrides.FirstOrDefault(); if (implementedAccessor == null) { continue; } var interfaceType = GetType(new TypeIdentity(implementedAccessor.DeclaringType.StripGenericParameters())); var implementedPropertyName = WeavingHelper.GetPropertyName(implementedAccessor.Name); var implementedProperty = interfaceType.FindProperty(implementedPropertyName); if (implementedProperty == null) { continue; } property.ImplementedProperties.Add(implementedProperty); property.IsExplicitInterfaceImplementation = true; if (context.Language != SourceLanguage.VbNet) { property.PersistentName = WeavingHelper.BuildComplexPersistentName(interfaceType, implementedProperty); } propertiesToImplement.Remove(implementedProperty); InheritPersistence(property, implementedProperty); } // Try associate remaining properties foreach (var property in propertiesToImplement) { PropertyInfo implementor; if (type.Properties.TryGetValue(property.Name, out implementor)) { implementor.ImplementedProperties.Add(property); InheritPersistence(implementor, property); } } }