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 PersistentTypeArgument() { var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true); var header = assembly.NetDirectory.MetadataHeader; var image = header.LockMetadata(); var importer = new ReferenceImporter(image); var argument = importer.ImportTypeSignature(typeof(object)); var customAttribute = new CustomAttribute( (ICustomAttributeType)importer.ImportMethod( typeof(DesignerAttribute).GetConstructor(new[] { typeof(Type) })), new CustomAttributeSignature(new[] { new CustomAttributeArgument(importer.ImportTypeSignature(typeof(Type)), new ElementSignature(argument)) })); image.Assembly.CustomAttributes.Add(customAttribute); header.UnlockMetadata(); image = header.LockMetadata(); Assert.Single(image.Assembly.CustomAttributes); Assert.Equal(argument, image.Assembly.CustomAttributes[0].Signature.FixedArguments[0].Elements[0].Value as ITypeDescriptor, _comparer); }
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 ImportGenericInstanceType() { var assembly = Utilities.CreateTempNetAssembly(); var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>(); var importer = new ReferenceImporter(tableStream); var signature = new GenericInstanceTypeSignature(CreateTypeReference(typeof(List <>))); var genericArg = CreateTypeDefOrRef(typeof(Form)); signature.GenericArguments.Add(genericArg); var newSignature = importer.ImportTypeSignature(signature); Assert.AreNotSame(signature, newSignature, "Imported signature is the same object as original."); Assert.IsTrue(_comparer.MatchTypes(signature, newSignature), "Imported signature does not match original."); Assert.IsTrue(tableStream.GetTable <TypeReference>().FirstOrDefault(x => _comparer.MatchTypes(x, signature.GenericType)) != null, "Generic type reference not added to table."); Assert.IsTrue(tableStream.GetTable <TypeReference>().FirstOrDefault(x => _comparer.MatchTypes(x, genericArg.Type)) != null, "Generic type argument not added to table."); }
public void PersistentVariables() { var methodBody = CreateDummyMethodBody(); var image = methodBody.Method.Image; var importer = new ReferenceImporter(image); var var1 = new VariableSignature(image.TypeSystem.Int32); var var2 = new VariableSignature(importer.ImportTypeSignature(typeof(Stream))); methodBody.Signature = new StandAloneSignature(new LocalVariableSignature(new[] { var1, var2 })); var mapping = image.Header.UnlockMetadata(); image = image.Header.LockMetadata(); methodBody = ((MethodDefinition)image.ResolveMember(mapping[methodBody.Method])).CilMethodBody; Assert.NotNull(methodBody.Signature); Assert.IsType <LocalVariableSignature>(methodBody.Signature.Signature); var localVarSig = (LocalVariableSignature)methodBody.Signature.Signature; Assert.Equal(2, localVarSig.Variables.Count); Assert.Equal(var1.VariableType, localVarSig.Variables[0].VariableType, _comparer); Assert.Equal(var2.VariableType, localVarSig.Variables[1].VariableType, _comparer); }
public void PersistentEnumArgument() { var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true); var header = assembly.NetDirectory.MetadataHeader; var image = header.LockMetadata(); var importer = new ReferenceImporter(image); const int argument = (int)DebuggableAttribute.DebuggingModes.EnableEditAndContinue; var customAttribute = new CustomAttribute( (ICustomAttributeType)importer.ImportMethod( typeof(DebuggableAttribute).GetConstructor(new[] { typeof(DebuggableAttribute.DebuggingModes) })), new CustomAttributeSignature(new[] { new CustomAttributeArgument(importer.ImportTypeSignature(typeof(DebuggableAttribute.DebuggingModes)), new ElementSignature(argument)) })); image.Assembly.CustomAttributes.Add(customAttribute); header.UnlockMetadata(); image = header.LockMetadata(); Assert.Single(image.Assembly.CustomAttributes); Assert.Equal(argument, image.Assembly.CustomAttributes[0].Signature.FixedArguments[0].Elements[0].Value); }
public void ImportGenericInstanceType() { var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true); var image = assembly.NetDirectory.MetadataHeader.LockMetadata(); var importer = new ReferenceImporter(image); var signature = new GenericInstanceTypeSignature(CreateTypeReference(typeof(List <>))); var genericArg = CreateTypeDefOrRef(typeof(Form)); signature.GenericArguments.Add(genericArg); var newSignature = importer.ImportTypeSignature(signature); Assert.NotSame(signature, newSignature); Assert.Equal(signature, newSignature, _comparer); var newGenericSiganture = (GenericInstanceTypeSignature)newSignature; Assert.Equal(image, newGenericSiganture.GenericType.Image); var genericArgElementType = newGenericSiganture.GenericArguments[0].GetElementType(); Assert.IsAssignableFrom <ITypeDefOrRef>(genericArgElementType); Assert.Equal(image, ((ITypeDefOrRef)genericArgElementType).Image); }
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 ResolveMethodGenericParameterWithMethod() { var genericInstance = new GenericInstanceMethodSignature(); genericInstance.TypeArguments.Add(_importer.ImportTypeSignature(typeof(string))); var context = new GenericContext(null, genericInstance); var parameter = new GenericParameterSignature(GenericParameterType.Method, 0); Assert.Equal("System.String", context.GetTypeArgument(parameter).FullName); }
public void ImportCorlibType() { var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true); var image = assembly.NetDirectory.MetadataHeader.LockMetadata(); var importer = new ReferenceImporter(image); var signature = image.TypeSystem.Byte; var newSignature = importer.ImportTypeSignature(signature); Assert.Same(signature, newSignature); }
public void ImportCorlibType() { var assembly = Utilities.CreateTempNetAssembly(); var metadataHeader = assembly.NetDirectory.MetadataHeader; var tableStream = metadataHeader.GetStream <TableStream>(); var importer = new ReferenceImporter(tableStream); var signature = metadataHeader.TypeSystem.Byte; var newSignature = importer.ImportTypeSignature(signature); Assert.AreSame(signature, newSignature, "Imported signature is not the same object as original."); }
public void ImportTypeDefOrRefSignature() { var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true); var image = assembly.NetDirectory.MetadataHeader.LockMetadata(); var importer = new ReferenceImporter(image); var signature = CreateTypeDefOrRef(typeof(Form)); var newSignature = importer.ImportTypeSignature(signature); Assert.NotSame(signature, newSignature); Assert.Equal(signature, newSignature, _comparer); }
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.ImportMember(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 OperandTypeMethod() { var methodBody = CreateDummyMethodBody(); var image = methodBody.Method.Image; var importer = new ReferenceImporter(image); var instructions = methodBody.Instructions; var simpleMethod = importer.ImportMethod(typeof(Console).GetMethod("WriteLine", new[] { typeof(string) })); var genericInstanceMethod = new MethodSpecification( new MemberReference( importer.ImportType(typeof(Activator)), "CreateInstance", new MethodSignature(new GenericParameterSignature(GenericParameterType.Method, 0)) { GenericParameterCount = 1, IsGeneric = true }), new GenericInstanceMethodSignature(importer.ImportTypeSignature(typeof(Stream)))); instructions.AddRange(new[] { CilInstruction.Create(CilOpCodes.Ldstr, "Some String"), CilInstruction.Create(CilOpCodes.Call, simpleMethod), CilInstruction.Create(CilOpCodes.Call, importer.ImportMethod(genericInstanceMethod)), CilInstruction.Create(CilOpCodes.Pop), 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(simpleMethod, instructions[1].Operand as IMemberReference, _comparer); Assert.Equal(genericInstanceMethod, instructions[2].Operand as IMemberReference, _comparer); }
private TSignature TestTypeSpecification <TSignature>(TSignature signature, ITypeDefOrRef baseType) where TSignature : TypeSpecificationSignature { var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, true); var image = assembly.NetDirectory.MetadataHeader.LockMetadata(); var importer = new ReferenceImporter(image); var newSignature = importer.ImportTypeSignature(signature); Assert.IsType <TSignature>(newSignature); Assert.NotSame(signature, newSignature); Assert.Equal(signature, newSignature, _comparer); var elementType = newSignature.GetElementType(); Assert.IsAssignableFrom <ITypeDefOrRef>(elementType); Assert.Equal(baseType, elementType, _comparer); Assert.Equal(image, ((ITypeDefOrRef)elementType).Image); return((TSignature)newSignature); }
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); }
private static TSignature TestTypeSpecification <TSignature>(TSignature signature, ITypeDefOrRef baseType) where TSignature : TypeSpecificationSignature { var assembly = Utilities.CreateTempNetAssembly(); var tableStream = assembly.NetDirectory.MetadataHeader.GetStream <TableStream>(); var importer = new ReferenceImporter(tableStream); var newSignature = importer.ImportTypeSignature(signature); Assert.IsInstanceOfType(newSignature, typeof(TSignature)); Assert.AreNotSame(signature, newSignature, "Imported signature is the same object as original."); Assert.IsTrue(_comparer.MatchTypes(signature, newSignature), "Imported signature does not match original."); Assert.IsTrue(tableStream.GetTable <TypeReference>().FirstOrDefault(x => _comparer.MatchTypes(x, baseType)) != null, "Base type reference not added to table."); return((TSignature)newSignature); }
/// <summary> /// Do Proxy Signature. /// </summary> /// <param name="IsNewobj"> Ditermine If The Processed Instruction Is CilOpCodes.NewObj. </param> /// <param name="Method"> Method to Call. </param> /// <returns> Proxy Method Sig. </returns> private static MethodSignature GetSignature(bool IsNewobj, IMethodDescriptor Method) { // Get Return Type. var _returntype = IsNewobj ? Method.DeclaringType.ToTypeSignature() : Method.Signature.ReturnType; // Assign Params Type. IList <TypeSignature> _params = new List <TypeSignature>(); /// Inserting TypeSigs From <param name="Method"/> Sig. foreach (var _tsig in Method.Signature.ParameterTypes) { _params.Add(_tsig); } // If Method Is HasThis Insert Object Sig. if (Method.Signature.HasThis && !IsNewobj) { _params.Insert(0, _importer.ImportTypeSignature(Method.Resolve().Parameters.ThisParameter.ParameterType)); } // Finally Return Maded Sig. return(MethodSignature.CreateStatic(_returntype, _params)); }
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); }
private static WindowsAssembly CreateTempAssembly() { var assembly = NetAssemblyFactory.CreateAssembly(DummyAssemblyName, false); var image = assembly.NetDirectory.MetadataHeader.LockMetadata(); var importer = new ReferenceImporter(image); var type = new TypeDefinition( TypeNamespace, TypeName, TypeAttributes.Public, importer.ImportType(typeof(object))); image.Assembly.Modules[0].TopLevelTypes.Add(type); var mainMethod = new MethodDefinition(MainMethodName, MethodAttributes.Public | MethodAttributes.Static, new MethodSignature(new[] { importer.ImportTypeSignature(typeof(string[])) }, image.TypeSystem.Void)); type.Methods.Add(mainMethod); mainMethod.MethodBody = new CilMethodBody(mainMethod); image.ManagedEntrypoint = mainMethod; return(assembly); }