public void AddStringReference() { const string testConstant = "Lorem ipsum."; // set up temp assembly. var assembly = Utilities.CreateTempNetAssembly(); var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); var methodTable = tableStream.GetTable<MethodDefinition>(); var importer = new ReferenceImporter(tableStream); // write code. var body = methodTable[0].MethodBody; body.Instructions.Clear(); body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Ldstr, testConstant)); body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Call, importer.ImportMethod(typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string) })))); body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Call, importer.ImportMethod(typeof(Console).GetMethod("ReadKey", Type.EmptyTypes)))); body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Pop)); body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Ret)); // build and validate. assembly = Utilities.RebuildNetAssembly(assembly); methodTable = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>().GetTable<MethodDefinition>(); var operand = methodTable[0].MethodBody.Instructions[0].Operand; Assert.IsInstanceOfType(operand, typeof(string)); Assert.AreEqual(testConstant, operand); }
public void CreateArrayField() { // set up temp assembly. var assembly = Utilities.CreateTempNetAssembly(); var typeSystem = assembly.NetDirectory.MetadataHeader.TypeSystem; var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); var fieldTable = tableStream.GetTable<FieldDefinition>(); var importer = new ReferenceImporter(tableStream); // create field. var arraySignature = new ArrayTypeSignature(typeSystem.Int32); arraySignature.Dimensions.Add(new ArrayDimension(2, 1)); arraySignature.Dimensions.Add(new ArrayDimension(2)); arraySignature.Dimensions.Add(new ArrayDimension()); var field = new FieldDefinition(FieldName, FieldAttributes.Public | FieldAttributes.Static, new FieldSignature(importer.ImportTypeSignature(arraySignature))); fieldTable.Add(field); // build and validate. assembly = Utilities.RebuildNetAssembly(assembly); fieldTable = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>().GetTable<FieldDefinition>(); field = fieldTable.First(x => x.Name == FieldName); Assert.IsInstanceOfType(field.Signature.FieldType, typeof(ArrayTypeSignature)); Utilities.ValidateType(arraySignature, field.Signature.FieldType); }
public void CreateSimpleSecurityDeclaration() { const string typeNamespace = "System.WitchCraft"; const string typeName = "MagicalWand"; // set up temp assembly. var assembly = Utilities.CreateTempNetAssembly(); var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); var typeTable = tableStream.GetTable<TypeDefinition>(); var declarationTable = tableStream.GetTable<SecurityDeclaration>(); var importer = new ReferenceImporter(tableStream); // create temp type. var type = new TypeDefinition(typeNamespace, typeName); type.MetadataRow.Column5 = 1; // FieldList type.MetadataRow.Column6 = 2; // MethodList. typeTable.Add(type); // create attribute. var securityAttribute = new SecurityAttributeSignature() { TypeName = typeof(TypeDescriptorPermissionAttribute).AssemblyQualifiedName, }; // create permission set. var permissionSet = new PermissionSetSignature(); permissionSet.Attributes.Add(securityAttribute); // create declaration. var declaration = new SecurityDeclaration(SecurityAction.Assert, permissionSet); type.SecurityDeclarations.Add(declaration); declarationTable.Add(declaration); assembly = Utilities.RebuildNetAssembly(assembly); tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); typeTable = tableStream.GetTable<TypeDefinition>(); type = typeTable.First(x => x.IsTypeOf(typeNamespace, typeName)); Assert.IsTrue(type.SecurityDeclarations.Count > 0); var newDeclaration = type.SecurityDeclarations[0]; Assert.AreEqual(declaration.Action, newDeclaration.Action); Assert.AreEqual(declaration.PermissionSet.Attributes.Count, newDeclaration.PermissionSet.Attributes.Count); for (int i = 0; i < declaration.PermissionSet.Attributes.Count; i++) { var attribute = declaration.PermissionSet.Attributes[i]; var newAttribute = newDeclaration.PermissionSet.Attributes[i]; Assert.AreEqual(attribute.TypeName, newAttribute.TypeName); } }
public void CreateAttributeWithEnumArgument() { // set up temp assembly. var assembly = Utilities.CreateTempNetAssembly(); var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); var assemblyTable = tableStream.GetTable<AssemblyDefinition>(); var attributeTable = tableStream.GetTable<CustomAttribute>(); var importer = new ReferenceImporter(tableStream); var assemblyDef = assemblyTable[0]; // create custom attribute. var signature = new CustomAttributeSignature(); signature.FixedArguments.Add( new CustomAttributeArgument(importer.ImportTypeSignature(typeof(DebuggableAttribute.DebuggingModes)), new ElementSignature((int)DebuggableAttribute.DebuggingModes.Default))); var attribute = new CustomAttribute(importer.ImportMethod(typeof(DebuggableAttribute).GetConstructor(new Type[] { typeof(DebuggableAttribute.DebuggingModes) })), signature); assemblyDef.CustomAttributes.Add(attribute); attributeTable.Add(attribute); // build and validate. assembly = Utilities.RebuildNetAssembly(assembly); tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); assemblyTable = tableStream.GetTable<AssemblyDefinition>(); assemblyDef = assemblyTable[0]; attributeTable = tableStream.GetTable<CustomAttribute>(); var newAttribute = attributeTable[0]; Assert.IsTrue(assemblyDef.CustomAttributes.Contains(newAttribute)); Assert.AreEqual(attribute.Constructor.FullName, newAttribute.Constructor.FullName); Assert.AreEqual(attribute.Signature.FixedArguments.Count, newAttribute.Signature.FixedArguments.Count); for (int i = 0; i < attribute.Signature.FixedArguments.Count; i++) Utilities.ValidateArgument(attribute.Signature.FixedArguments[i], newAttribute.Signature.FixedArguments[i]); }
public void TestInterpretAsArray() { var elementType = ElementType.I4; int[] expected = new int[] { 1, 2, 3 }; byte[] data = new byte[] { 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0 }; var assembly = Utilities.CreateTempNetAssembly(); var importer = new ReferenceImporter(assembly.NetDirectory.MetadataHeader.GetStream<TableStream>()); var fieldType = new TypeDefinition(string.Empty, "__StaticArrayInitTypeSize=" + data.Length, importer.ImportType(typeof(ValueType))); var field = new FieldDefinition(FieldName, FieldAttributes.Public | FieldAttributes.Static | FieldAttributes.HasFieldRva, new FieldSignature(new TypeDefOrRefSignature(fieldType) { IsValueType = true })); var fieldRva = new FieldRva(field, data); int[] actual = fieldRva.InterpretAsArray(elementType).Cast<int>().ToArray(); Assert.AreEqual(expected.Length, actual.Length, "Length of arrays differ."); for (int i = 0; i < actual.Length; i++) Assert.AreEqual(expected[i], actual[i], "Element " + i + " differs from expected."); }
public void CreateCustomSizeFieldRva() { const int dataSize = 128; var assembly = Utilities.CreateTempNetAssembly(); var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); var typeTable = tableStream.GetTable<TypeDefinition>(); var classLayoutTable = tableStream.GetTable<ClassLayout>(); var importer = new ReferenceImporter(tableStream); var type = new TypeDefinition(string.Empty, "__StaticArrayInitTypeSize=" + dataSize, importer.ImportType(typeof(ValueType))); type.MetadataRow.Column5 = 2; // FieldList type.MetadataRow.Column6 = 2; // MethodList typeTable.Add(type); var layout = new ClassLayout(type, 128, 1); type.ClassLayout = layout; classLayoutTable.Add(layout); TestFieldRva(assembly, new TypeDefOrRefSignature(type), Enumerable.Repeat((byte)1, dataSize).ToArray(), false); }
public void CreateSimpleField() { var type = typeof(Process); // set up temp assembly. var assembly = Utilities.CreateTempNetAssembly(); var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); var fieldTable = tableStream.GetTable<FieldDefinition>(); var importer = new ReferenceImporter(tableStream); // create field. var field = new FieldDefinition(FieldName, FieldAttributes.Public | FieldAttributes.Static, new FieldSignature(importer.ImportTypeSignature(type))); fieldTable.Add(field); // build and validate. assembly = Utilities.RebuildNetAssembly(assembly); fieldTable = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>().GetTable<FieldDefinition>(); field = fieldTable.First(x => x.Name == FieldName); Utilities.ValidateType(type, field.Signature.FieldType); }
public void CreateRequiredModifierField() { // set up temp assembly. var assembly = Utilities.CreateTempNetAssembly(); var typeSystem = assembly.NetDirectory.MetadataHeader.TypeSystem; var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); var fieldTable = tableStream.GetTable<FieldDefinition>(); var importer = new ReferenceImporter(tableStream); // create field. var typeSignature = new RequiredModifierSignature(importer.ImportType(typeof(IsVolatile)), typeSystem.Int32); var field = new FieldDefinition(FieldName, FieldAttributes.Public | FieldAttributes.Static, new FieldSignature(typeSignature)); fieldTable.Add(field); // build and validate. assembly = Utilities.RebuildNetAssembly(assembly); fieldTable = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>().GetTable<FieldDefinition>(); field = fieldTable.First(x => x.Name == FieldName); Assert.IsInstanceOfType(field.Signature.FieldType, typeof(RequiredModifierSignature)); var newTypeSignature = (RequiredModifierSignature)field.Signature.FieldType; Utilities.ValidateType(typeSignature.ModifierType, newTypeSignature.ModifierType); Utilities.ValidateType(typeSignature.BaseType, newTypeSignature.BaseType); }
public void CreateGenericInstanceFieldReflection() { // set up temp assembly. var assembly = Utilities.CreateTempNetAssembly(); var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); var fieldTable = tableStream.GetTable<FieldDefinition>(); var importer = new ReferenceImporter(tableStream); // create field. var typeSignature = (GenericInstanceTypeSignature)importer.ImportTypeSignature(typeof(List<string>)); var field = new FieldDefinition(FieldName, FieldAttributes.Public | FieldAttributes.Static, new FieldSignature(typeSignature)); fieldTable.Add(field); // build and validate. assembly = Utilities.RebuildNetAssembly(assembly); fieldTable = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>().GetTable<FieldDefinition>(); field = fieldTable.First(x => x.Name == FieldName); Assert.IsInstanceOfType(field.Signature.FieldType, typeof(GenericInstanceTypeSignature)); var newTypeSignature = (GenericInstanceTypeSignature)field.Signature.FieldType; Utilities.ValidateType(typeSignature.GenericType, newTypeSignature.GenericType); Assert.AreEqual(typeSignature.GenericArguments.Count, newTypeSignature.GenericArguments.Count); for (int i = 0; i < typeSignature.GenericArguments.Count; i++) Assert.AreEqual(typeSignature.GenericArguments[i].FullName, newTypeSignature.GenericArguments[i].FullName); }
public void CreateAttributeWithNamedArgument() { const string fieldName = "MyField"; const string argumentValue = "MyXmlAttribute"; const string propertyName = "IsNullable"; const bool propertyValue = true; // set up temp assembly. var assembly = Utilities.CreateTempNetAssembly(); var typeSystem = assembly.NetDirectory.MetadataHeader.TypeSystem; var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); var fieldTable = tableStream.GetTable<FieldDefinition>(); var attributeTable = tableStream.GetTable<CustomAttribute>(); var importer = new ReferenceImporter(tableStream); // create temp field. var field = new FieldDefinition(fieldName, FieldAttributes.Static, new FieldSignature(typeSystem.String)); fieldTable.Add(field); // create custom attribute. var signature = new CustomAttributeSignature(); signature.FixedArguments.Add( new CustomAttributeArgument(typeSystem.String, new ElementSignature(argumentValue))); signature.NamedArguments.Add( new CustomAttributeNamedArgument() { ArgumentMemberType = CustomAttributeArgumentMemberType.Property, ArgumentType = typeSystem.Boolean, MemberName = propertyName, Argument = new CustomAttributeArgument(typeSystem.Boolean, new ElementSignature(propertyValue)) }); var attribute = new CustomAttribute(importer.ImportMethod(typeof(XmlAttributeAttribute).GetConstructor(new Type[] { typeof(string) })), signature); field.CustomAttributes.Add(attribute); attributeTable.Add(attribute); // build and validate. assembly = Utilities.RebuildNetAssembly(assembly); fieldTable = tableStream.GetTable<FieldDefinition>(); field = fieldTable.First(x => x.Name == fieldName); attributeTable = tableStream.GetTable<CustomAttribute>(); var newAttribute = attributeTable[0]; Assert.IsTrue(field.CustomAttributes.Contains(newAttribute)); Assert.AreEqual(attribute.Constructor.FullName, newAttribute.Constructor.FullName); Assert.AreEqual(attribute.Signature.FixedArguments.Count, newAttribute.Signature.FixedArguments.Count); for (int i = 0; i < attribute.Signature.FixedArguments.Count; i++) { Utilities.ValidateArgument(attribute.Signature.FixedArguments[i], newAttribute.Signature.FixedArguments[i]); } Assert.AreEqual(attribute.Signature.NamedArguments.Count, newAttribute.Signature.NamedArguments.Count); for (int i = 0; i < attribute.Signature.NamedArguments.Count; i++) { Utilities.ValidateNamedArgument(attribute.Signature.NamedArguments[i], newAttribute.Signature.NamedArguments[i]); } }
public void CreateSimpleAttribute() { // set up temp assembly. var assembly = Utilities.CreateTempNetAssembly(); var typeSystem = assembly.NetDirectory.MetadataHeader.TypeSystem; var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); var fieldTable = tableStream.GetTable<FieldDefinition>(); var attributeTable = tableStream.GetTable<CustomAttribute>(); var importer = new ReferenceImporter(tableStream); // create field. var field = new FieldDefinition("MyField", FieldAttributes.Public | FieldAttributes.Static, new FieldSignature(typeSystem.String)); fieldTable.Add(field); // create custom attribute. var signature = new CustomAttributeSignature(); signature.FixedArguments.Add(new CustomAttributeArgument(typeSystem.String, new ElementSignature("Lorem ipsum dolor sit amet."))); signature.FixedArguments.Add(new CustomAttributeArgument(typeSystem.Boolean, new ElementSignature(true))); var attribute = new CustomAttribute(importer.ImportMethod(typeof(ObsoleteAttribute).GetConstructor(new Type[] { typeof(string), typeof(bool) })), signature); field.CustomAttributes.Add(attribute); attributeTable.Add(attribute); // build and validate. assembly = Utilities.RebuildNetAssembly(assembly); tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); fieldTable = tableStream.GetTable<FieldDefinition>(); field = fieldTable[0]; attributeTable = tableStream.GetTable<CustomAttribute>(); var newAttribute = attributeTable[0]; Assert.IsTrue(field.CustomAttributes.Contains(newAttribute)); Assert.AreEqual(attribute.Constructor.FullName, newAttribute.Constructor.FullName); Assert.AreEqual(attribute.Signature.FixedArguments.Count, newAttribute.Signature.FixedArguments.Count); for (int i = 0; i < attribute.Signature.FixedArguments.Count; i++) Assert.AreEqual(attribute.Signature.FixedArguments[i].Elements[0].Value, newAttribute.Signature.FixedArguments[i].Elements[0].Value); }
public void ImportUsingReflection() { // set up temp assembly. var assembly = Utilities.CreateTempNetAssembly(); var tableStream = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>(); var methodTable = tableStream.GetTable<MethodDefinition>(); var importer = new ReferenceImporter(tableStream); // import members. var originalWriteLine = typeof(Console).GetMethod("WriteLine", new Type[] { typeof(int) }); var newWriteLine = importer.ImportMethod(originalWriteLine); Utilities.ValidateMethod(originalWriteLine, newWriteLine); var originalReadKey = typeof(Console).GetMethod("ReadKey", Type.EmptyTypes); var newReadKey = importer.ImportMethod(originalReadKey); Utilities.ValidateMethod(originalReadKey, newReadKey); // write code. var body = methodTable[0].MethodBody; body.Instructions.Clear(); body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Ldc_I4, 1337)); body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Call, newWriteLine)); body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Call, newReadKey)); body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Pop)); body.Instructions.Add(MsilInstruction.Create(MsilOpCodes.Ret)); // build and validate. assembly = Utilities.RebuildNetAssembly(assembly); methodTable = assembly.NetDirectory.MetadataHeader.GetStream<TableStream>().GetTable<MethodDefinition>(); var writeLineReference = methodTable[methodTable.Count - 1].MethodBody.Instructions[1].Operand; Assert.IsInstanceOfType(writeLineReference, typeof(MemberReference)); Utilities.ValidateMethod(originalWriteLine, (MemberReference)writeLineReference); var readKeyReference = methodTable[methodTable.Count - 1].MethodBody.Instructions[2].Operand; Assert.IsInstanceOfType(readKeyReference, typeof(MemberReference)); Utilities.ValidateMethod(originalReadKey, (MemberReference)readKeyReference); }