public void ComplexGenericTypeInstance()
{
var spec = CreateDummyType();
var image = spec.Image;
var importer = new ReferenceImporter(image);
// Tuple<Tuple<decimal, decimal>, Tuple<decimal, decimal>>
var signature =
new GenericInstanceTypeSignature(importer.ImportType(typeof(Tuple <,>)),
new GenericInstanceTypeSignature(
importer.ImportType(typeof(Tuple <,>)),
importer.ImportTypeSignature(typeof(decimal)),
importer.ImportTypeSignature(typeof(decimal))),
new GenericInstanceTypeSignature(
importer.ImportType(typeof(Tuple <,>)),
importer.ImportTypeSignature(typeof(decimal)),
importer.ImportTypeSignature(typeof(decimal))));
spec.Signature = signature;
var header = image.Header;
var mapping = header.UnlockMetadata();
var newImage = header.LockMetadata();
var newSpec = (TypeSpecification)newImage.ResolveMember(mapping[spec]);
Assert.Equal(signature, newSpec.Signature, Comparer);
}
public void OperandTypeType()
{
var methodBody = CreateDummyMethodBody();
var image = methodBody.Method.Image;
var importer = new ReferenceImporter(image);
var instructions = methodBody.Instructions;
var simpleType = importer.ImportType(typeof(Form));
instructions.Add(CilInstruction.Create(CilOpCodes.Ldtoken, simpleType));
instructions.Add(CilInstruction.Create(CilOpCodes.Pop));
var genericType = importer.ImportType(typeof(List <Form>));
instructions.Add(CilInstruction.Create(CilOpCodes.Ldtoken, genericType));
instructions.Add(CilInstruction.Create(CilOpCodes.Pop));
instructions.Add(CilInstruction.Create(CilOpCodes.Ret));
var mapping = image.Header.UnlockMetadata();
image = image.Header.LockMetadata();
var newMethod = (MethodDefinition)image.ResolveMember(mapping[methodBody.Method]);
instructions = newMethod.CilMethodBody.Instructions;
Assert.Equal(simpleType, instructions[0].Operand as ITypeDescriptor, _comparer);
Assert.Equal(genericType, instructions[2].Operand as ITypeDescriptor, _comparer);
}
public void PersistentNestedClasses()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var header = assembly.NetDirectory.MetadataHeader;
var image = header.LockMetadata();
var importer = new ReferenceImporter(image);
var type = new TypeDefinition("SomeNamespace", "SomeType", TypeAttributes.Public,
importer.ImportType(typeof(object)));
var nestedType = new TypeDefinition(null, "NestedType", TypeAttributes.NestedPublic,
importer.ImportType(typeof(object)));
type.NestedClasses.Add(new NestedClass(nestedType));
image.Assembly.Modules[0].TopLevelTypes.Add(type);
var mapping = header.UnlockMetadata();
image = header.LockMetadata();
type = (TypeDefinition)image.ResolveMember(mapping[type]);
Assert.Single(type.NestedClasses);
Assert.Same(type, type.NestedClasses[0].EnclosingClass);
Assert.Equal(nestedType, type.NestedClasses[0].Class, _comparer);
Assert.DoesNotContain(type.NestedClasses[0].Class, image.Assembly.Modules[0].TopLevelTypes);
Assert.Contains(type.NestedClasses[0].Class, image.Assembly.Modules[0].GetAllTypes());
}
public void PersistentMethodImplementations()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var header = assembly.NetDirectory.MetadataHeader;
var image = header.LockMetadata();
var importer = new ReferenceImporter(image);
var type = new TypeDefinition("SomeNamespace", "SomeType", TypeAttributes.Public,
importer.ImportType(typeof(object)));
var @interface = importer.ImportType(typeof(IList));
type.Interfaces.Add(new InterfaceImplementation(@interface));
var addMethodRef = (IMethodDefOrRef)importer.ImportMethod(typeof(IList).GetMethod("Add", new[] { typeof(object) }));
var addMethodDef = new MethodDefinition("Add", MethodAttributes.Public,
(MethodSignature)addMethodRef.Signature);
type.Methods.Add(addMethodDef);
type.MethodImplementations.Add(new MethodImplementation(addMethodDef,
addMethodRef));
image.Assembly.Modules[0].TopLevelTypes.Add(type);
var mapping = header.UnlockMetadata();
image = header.LockMetadata();
type = (TypeDefinition)image.ResolveMember(mapping[type]);
Assert.Single(type.MethodImplementations);
Assert.Same(type, type.MethodImplementations[0].Class);
Assert.Equal(addMethodDef, type.MethodImplementations[0].MethodBody, _comparer);
Assert.Equal(addMethodRef, type.MethodImplementations[0].MethodDeclaration, _comparer);
}
public void ImportNewTypeShouldCreateNewReference()
{
var type = new TypeReference(_dummyAssembly, "SomeNamespace", "SomeName");
var result = _importer.ImportType(type);
Assert.Equal(type, result, _comparer);
Assert.Equal(_module, result.Module);
}
public void ResolveTypeGenericParameterWithType()
{
var genericInstance = new GenericInstanceTypeSignature(_importer.ImportType(typeof(List <>)), false);
genericInstance.TypeArguments.Add(_importer.ImportTypeSignature(typeof(string)));
var context = new GenericContext(genericInstance, null);
var parameter = new GenericParameterSignature(GenericParameterType.Type, 0);
Assert.Equal("System.String", context.GetTypeArgument(parameter).FullName);
}
public void GenericType(GenericParameterType[] parameterTypes, int[] parameterIndices)
{
// Tuple<!0, !1, !2>
var genericInstance = new GenericInstanceTypeSignature(_importer.ImportType(typeof(Tuple <, ,>)),
new GenericParameterSignature(parameterTypes[0], parameterIndices[0]),
new GenericParameterSignature(parameterTypes[1], parameterIndices[1]),
new GenericParameterSignature(parameterTypes[2], parameterIndices[2])
);
Assert.Equal(new GenericInstanceTypeSignature(_importer.ImportType(typeof(Tuple <, ,>)),
GetTypeArguments(parameterTypes[0])[parameterIndices[0]],
GetTypeArguments(parameterTypes[1])[parameterIndices[1]],
GetTypeArguments(parameterTypes[2])[parameterIndices[2]]
), genericInstance.InstantiateGenericTypes(_context), Comparer);
}
public void ImportNewTypeReference()
{
var assembly = Utilities.CreateTempNetAssembly();
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var importer = new ReferenceImporter(tableStream);
var typeRefTable = tableStream.GetTable <TypeReference>();
var assemblyRefTable = tableStream.GetTable <AssemblyReference>();
const string typeNamespace = "System.Windows.Forms";
const string typeName = "Form";
var assemblyDescr = new ReflectionAssemblyNameWrapper(typeof(Form).Assembly.GetName());
var reference = new TypeReference(importer.ImportAssembly(assemblyDescr), typeNamespace, typeName);
var newReference = importer.ImportType(reference);
Assert.AreNotSame(reference, newReference,
"Imported reference is the same object as original.");
Assert.IsTrue(typeRefTable.Contains(newReference),
"Imported reference not added to reference table.");
Assert.IsTrue(_comparer.MatchTypes(reference, newReference),
"Imported reference does not match original.");
Assert.IsTrue(assemblyRefTable.FirstOrDefault(x => _comparer.MatchAssemblies(x, assemblyDescr)) != null,
"Assembly reference not added to reference table.");
}
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 CreateGenericInstanceField()
{
// 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 GenericInstanceTypeSignature(importer.ImportType(typeof(List <>)));
typeSignature.GenericArguments.Add(typeSystem.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);
}
}
private TypeSpecification CreateDummyType()
{
var assembly = NetAssemblyFactory.CreateAssembly("SomeAssembly", true);
var image = assembly.NetDirectory.MetadataHeader.LockMetadata();
var importer = new ReferenceImporter(image);
var typeSpec = (TypeSpecification)importer.ImportType(new TypeSpecification(image.TypeSystem.Void));
var method = new MethodDefinition("SomeMethod",
MethodAttributes.Public | MethodAttributes.Static,
new MethodSignature(image.TypeSystem.Void));
method.CilMethodBody = new CilMethodBody(method)
{
Instructions =
{
CilInstruction.Create(CilOpCodes.Ldtoken, typeSpec),
CilInstruction.Create(CilOpCodes.Pop),
CilInstruction.Create(CilOpCodes.Ret),
}
};
image.Assembly.Modules[0].TopLevelTypes[0].Methods.Add(method);
return(typeSpec);
}
public void NewTypeSpecification()
{
var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld);
// Import arbitrary generic method.
var importer = new ReferenceImporter(module);
var specification = importer.ImportType(typeof(List <object>));
// Ensure method reference is added to the module by referencing it in main.
var instructions = module.ManagedEntrypointMethod.CilMethodBody.Instructions;
instructions.Insert(0, CilOpCodes.Ldtoken, specification);
instructions.Insert(1, CilOpCodes.Pop);
// Rebuild.
var builder = new ManagedPEImageBuilder();
var result = builder.CreateImage(module);
// Assert valid token.
var newToken = result.TokenMapping[specification];
Assert.NotEqual(0u, newToken.Rid);
// Assert token resolves to the same method reference.
var newModule = ModuleDefinition.FromImage(result.ConstructedImage);
var newReference = (TypeSpecification)newModule.LookupMember(newToken);
Assert.Equal(specification.Name, newReference.Name);
}
public void NewTypeReference()
{
var module = ModuleDefinition.FromBytes(Properties.Resources.HelloWorld);
// Import arbitrary type as reference.
var importer = new ReferenceImporter(module);
var reference = importer.ImportType(typeof(MemoryStream));
// Ensure type ref is added to the module by adding a dummy field referencing it.
module.GetOrCreateModuleType().Fields.Add(new FieldDefinition(
"MyField",
FieldAttributes.Public | FieldAttributes.Static,
FieldSignature.CreateStatic(reference.ToTypeSignature())));
// Rebuild.
var builder = new ManagedPEImageBuilder();
var result = builder.CreateImage(module);
// Assert valid token.
var newToken = result.TokenMapping[reference];
Assert.NotEqual(0u, newToken.Rid);
// Assert token resolves to the same type reference.
var newModule = ModuleDefinition.FromImage(result.ConstructedImage);
var newReference = (TypeReference)newModule.LookupMember(newToken);
Assert.Equal(reference.Namespace, newReference.Namespace);
Assert.Equal(reference.Name, newReference.Name);
}
public void ImportExternalTypeDefinition()
{
var externalAssembly = Utilities.CreateTempNetAssembly();
var tableStream = externalAssembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var externalAssemblyDef = tableStream.GetTable <AssemblyDefinition>().First();
var externalType = new TypeDefinition("SomeNamespace", "SomeName");
tableStream.GetTable <TypeDefinition>().Add(externalType);
var assembly = Utilities.CreateTempNetAssembly();
tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var importer = new ReferenceImporter(tableStream);
var newReference = importer.ImportType(externalType);
Assert.AreNotSame(externalType, newReference,
"Imported reference is the same object as original.");
Assert.IsTrue(_comparer.MatchTypes(externalType, newReference),
"Imported reference does not match original.");
Assert.IsTrue(tableStream.GetTable <AssemblyReference>().FirstOrDefault(x => _comparer.MatchAssemblies(x, externalAssemblyDef)) != null,
"Assembly reference not added to table.");
}
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 PersistentExceptionHandlers()
{
var methodBody = CreateDummyMethodBody();
var image = methodBody.Method.Image;
var importer = new ReferenceImporter(image);
var writeLine = importer.ImportMethod(typeof(Console).GetMethod("WriteLine", new[] { typeof(int) }));
var instructions = methodBody.Instructions;
var tryStart = CilInstruction.Create(CilOpCodes.Nop);
var handlerStart = CilInstruction.Create(CilOpCodes.Pop);
var handlerEnd = CilInstruction.Create(CilOpCodes.Nop);
instructions.AddRange(new[]
{
tryStart,
CilInstruction.Create(CilOpCodes.Ldc_I4_0),
CilInstruction.Create(CilOpCodes.Call, writeLine),
CilInstruction.Create(CilOpCodes.Leave, handlerEnd),
handlerStart,
CilInstruction.Create(CilOpCodes.Ldc_I4_1),
CilInstruction.Create(CilOpCodes.Ldc_I4_2),
CilInstruction.Create(CilOpCodes.Add),
CilInstruction.Create(CilOpCodes.Call, writeLine),
CilInstruction.Create(CilOpCodes.Leave, handlerEnd),
handlerEnd,
CilInstruction.Create(CilOpCodes.Ret),
});
var exceptionType = importer.ImportType(typeof(Exception));
methodBody.ExceptionHandlers.Add(new ExceptionHandler(ExceptionHandlerType.Exception)
{
TryStart = tryStart,
TryEnd = handlerStart,
HandlerStart = handlerStart,
HandlerEnd = handlerEnd,
CatchType = exceptionType
});
var mapping = image.Header.UnlockMetadata();
image = image.Header.LockMetadata();
var instructionComparer = new CilInstructionComparer();
var newMethod = (MethodDefinition)image.ResolveMember(mapping[methodBody.Method]);
Assert.Equal(1, newMethod.CilMethodBody.ExceptionHandlers.Count);
var handler = newMethod.CilMethodBody.ExceptionHandlers[0];
Assert.Equal(tryStart, handler.TryStart, instructionComparer);
Assert.Equal(handlerStart, handler.TryEnd, instructionComparer);
Assert.Equal(handlerStart, handler.HandlerStart, instructionComparer);
Assert.Equal(handlerEnd, handler.HandlerEnd, instructionComparer);
Assert.Equal(exceptionType, handler.CatchType, _comparer);
}
public TypeHelper(ReferenceImporter importer)
{
var scope = importer.TargetModule.CorLibTypeFactory.CorLibScope;
_arrayType = importer.ImportType(new TypeReference(scope, "System", "Array"));
_objectType = importer.ImportType(new TypeReference(scope, "System", "Object"));
var factory = importer.TargetModule.CorLibTypeFactory;
_signedIntegralTypes = new TypeSignature[]
{
factory.SByte,
factory.Int16,
factory.Int32,
factory.IntPtr,
factory.Int64,
};
_unsignedIntegralTypes = new TypeSignature[]
{
factory.Byte,
factory.UInt16,
factory.UInt32,
factory.UIntPtr,
factory.UInt64,
};
_integralTypes = new TypeSignature[]
{
factory.SByte,
factory.Byte,
factory.Int16,
factory.UInt16,
factory.Int32,
factory.UInt32,
factory.IntPtr,
factory.UIntPtr,
factory.Int64,
factory.UInt64,
};
}
public void PersistentNativeMethod()
{
var assembly = CreateTempAssembly();
assembly.NetDirectory.Flags &= ~ImageNetDirectoryFlags.IlOnly;
var image = assembly.NetDirectory.MetadataHeader.Image;
var importer = new ReferenceImporter(image);
var nativeMethod = new MethodDefinition("MyNativeMethod",
MethodAttributes.Assembly | MethodAttributes.Static | MethodAttributes.PInvokeImpl,
new MethodSignature(image.TypeSystem.Int32));
nativeMethod.ImplAttributes = MethodImplAttributes.Native
| MethodImplAttributes.Unmanaged
| MethodImplAttributes.PreserveSig;
var nativeBody = new X86MethodBody();
nativeBody.Instructions.Add(new X86Instruction
{
Mnemonic = X86Mnemonic.Mov,
OpCode = X86OpCodes.Mov_Eax_Imm1632,
Operand1 = new X86Operand(X86Register.Eax),
Operand2 = new X86Operand(1337),
});
nativeBody.Instructions.Add(new X86Instruction
{
Mnemonic = X86Mnemonic.Retn,
OpCode = X86OpCodes.Retn,
});
nativeMethod.MethodBody = nativeBody;
image.Assembly.Modules[0].TopLevelTypes[0].Methods.Add(nativeMethod);
var mainMethod = image.Assembly.Modules[0].TopLevelTypes.First(x => x.Name == TypeName).Methods.First(x => x.Name == MainMethodName);
var instructions = mainMethod.CilMethodBody.Instructions;
instructions.AddRange(new[]
{
CilInstruction.Create(CilOpCodes.Ldstr, "The secret number is: {0}"),
CilInstruction.Create(CilOpCodes.Call, nativeMethod),
CilInstruction.Create(CilOpCodes.Box, importer.ImportType(typeof(int))),
CilInstruction.Create(CilOpCodes.Call,
importer.ImportMethod(
typeof(Console).GetMethod("WriteLine", new[] { typeof(string), typeof(object) }))),
CilInstruction.Create(CilOpCodes.Ret)
});
assembly.NetDirectory.MetadataHeader.UnlockMetadata();
_context.VerifyOutput(assembly, "The secret number is: 1337");
}
public void MaliciousMetadataLoop2()
{
var spec = CreateDummyType();
var image = spec.Image;
var importer = new ReferenceImporter(image);
spec.Signature =
new GenericInstanceTypeSignature(importer.ImportType(typeof(Tuple <,>)),
new MaliciousTypeSignature(
importer.ImportType(typeof(object)),
spec),
importer.ImportTypeSignature(typeof(decimal)));
var header = image.Header;
var mapping = header.UnlockMetadata();
var newImage = header.LockMetadata();
var newSpec = (TypeSpecification)newImage.ResolveMember(mapping[spec]);
Assert.NotEqual(spec.Signature, newSpec.Signature, Comparer);
}
public void ImportTypeSpecification()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var image = assembly.NetDirectory.MetadataHeader.LockMetadata();
var importer = new ReferenceImporter(image);
var typeSpec = new TypeSpecification(CreateTypeDefOrRef(typeof(Form)));
var newSpec = importer.ImportType(typeSpec);
Assert.NotSame(typeSpec, newSpec);
Assert.Equal(typeSpec, newSpec, _comparer);
}
public TypeHelper(ReferenceImporter importer)
{
_arrayType = importer.ImportType(typeof(Array));
_objectType = importer.ImportType(typeof(object));
var typeSystem = importer.TargetImage.TypeSystem;
_signedIntegralTypes = new TypeSignature[]
{
typeSystem.SByte,
typeSystem.Int16,
typeSystem.Int32,
typeSystem.IntPtr,
typeSystem.Int64,
};
_unsignedIntegralTypes = new TypeSignature[]
{
typeSystem.Byte,
typeSystem.UInt16,
typeSystem.UInt32,
typeSystem.UIntPtr,
typeSystem.UInt64,
};
_integralTypes = new TypeSignature[]
{
typeSystem.SByte,
typeSystem.Byte,
typeSystem.Int16,
typeSystem.UInt16,
typeSystem.Int32,
typeSystem.UInt32,
typeSystem.IntPtr,
typeSystem.UIntPtr,
typeSystem.Int64,
typeSystem.UInt64,
};
}
public void PersistentVTables()
{
var assembly = CreateTempAssembly();
var header = assembly.NetDirectory.MetadataHeader;
var importer = new ReferenceImporter(header.Image);
var type = new TypeDefinition(null, "SomeType", TypeAttributes.Public, importer.ImportType(typeof(object)));
for (int i = 0; i < 10; i++)
{
var method = new MethodDefinition("Method" + i, MethodAttributes.Public | MethodAttributes.Virtual,
new MethodSignature(header.Image.TypeSystem.Void));
method.MethodBody = new CilMethodBody(method)
{
Instructions = { CilInstruction.Create(CilOpCodes.Ret) }
};
type.Methods.Add(method);
}
header.Image.Assembly.Modules[0].TopLevelTypes.Add(type);
var mapping = header.UnlockMetadata();
var directory = new VTablesDirectory();
var vTableHeader = new VTableHeader()
{
Attributes = VTableAttributes.Is32Bit,
};
foreach (var method in type.Methods)
{
vTableHeader.Table.Add(header.GetStream <TableStream>().ResolveRow(mapping[method]));
}
directory.VTableHeaders.Add(vTableHeader);
assembly.NetDirectory.VTablesDirectory = directory;
using (var stream = new MemoryStream())
{
assembly.Write(new BinaryStreamWriter(stream), new CompactNetAssemblyBuilder(assembly));
assembly = WindowsAssembly.FromBytes(stream.ToArray());
directory = assembly.NetDirectory.VTablesDirectory;
Assert.NotNull(directory);
Assert.Equal(1, directory.VTableHeaders.Count);
Assert.Equal(type.Methods.Select(x => mapping[x]),
directory.VTableHeaders[0].Table.Select(x => x.MetadataToken));
}
}
public void ImportInternalTypeDefinition()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var image = assembly.NetDirectory.MetadataHeader.LockMetadata();
var importer = new ReferenceImporter(image);
var typeDef = new TypeDefinition("SomeNamespace", "SomeName");
image.Assembly.Modules[0].TopLevelTypes.Add(typeDef);
var newReference = importer.ImportType(typeDef);
Assert.Same(typeDef, newReference);
}
public void PersistentInterfaces()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var header = assembly.NetDirectory.MetadataHeader;
var image = header.LockMetadata();
var importer = new ReferenceImporter(image);
var type = new TypeDefinition("SomeNamespace", "SomeType", TypeAttributes.Public,
importer.ImportType(typeof(object)));
var @interface = importer.ImportType(typeof(IList));
type.Interfaces.Add(new InterfaceImplementation(@interface));
image.Assembly.Modules[0].TopLevelTypes.Add(type);
var mapping = header.UnlockMetadata();
image = header.LockMetadata();
type = (TypeDefinition)image.ResolveMember(mapping[type]);
Assert.Single(type.Interfaces);
Assert.Same(type, type.Interfaces[0].Class);
Assert.Equal(@interface, type.Interfaces[0].Interface, _comparer);
}
public void ImportReflectionType()
{
var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true);
var image = assembly.NetDirectory.MetadataHeader.LockMetadata();
var importer = new ReferenceImporter(image);
var assemblyDescr = new ReflectionAssemblyNameWrapper(typeof(Form).Assembly.GetName());
var expected = new TypeReference(new AssemblyReference(assemblyDescr), typeof(Form).Namespace, typeof(Form).Name);
var newReference = importer.ImportType(typeof(Form));
Assert.Equal(expected, newReference, _comparer);
Assert.Equal(image, newReference.Image);
Assert.Contains(image.Assembly.AssemblyReferences, x => _comparer.Equals(x, assemblyDescr));
}
public void ImportInternalTypeDefinition()
{
var assembly = Utilities.CreateTempNetAssembly();
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var importer = new ReferenceImporter(tableStream);
var typeDef = new TypeDefinition("SomeNamespace", "SomeName");
tableStream.GetTable <TypeDefinition>().Add(typeDef);
var newReference = importer.ImportType(typeDef);
Assert.AreSame(typeDef, newReference,
"Imported reference is not the same object as original.");
}
public void ImportTypeSpecification()
{
var assembly = Utilities.CreateTempNetAssembly();
var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>();
var importer = new ReferenceImporter(tableStream);
var typeSpec = new TypeSpecification(CreateTypeDefOrRef(typeof(Form)));
var newSpec = importer.ImportType(typeSpec);
Assert.AreNotSame(typeSpec, newSpec,
"Imported type is the same object as original.");
Assert.IsTrue(_comparer.MatchTypes(typeSpec, newSpec));
}
public void ThisParameterFromValueType()
{
var methodBody = CreateDummyMethodBody();
var method = methodBody.Method;
var importer = new ReferenceImporter(method.Image);
method.DeclaringType.BaseType = importer.ImportType(typeof(ValueType));
method.IsStatic = false;
method.Signature.HasThis = true;
Assert.Equal(new ByReferenceTypeSignature(method.DeclaringType.ToTypeSignature()),
methodBody.ThisParameter.ParameterType,
_comparer);
}
public void SingleArgGenericTypeInstance()
{
var spec = CreateDummyType();
var image = spec.Image;
var importer = new ReferenceImporter(image);
var signature = new GenericInstanceTypeSignature(importer.ImportType(typeof(List <>)), image.TypeSystem.String);
spec.Signature = signature;
var header = image.Header;
var mapping = header.UnlockMetadata();
var newImage = header.LockMetadata();
var newSpec = (TypeSpecification)newImage.ResolveMember(mapping[spec]);
Assert.Equal(signature, newSpec.Signature, Comparer);
}
