// In here, we're defining a class, foo_Task, derived from our DefinedTask class. This allows us to write the bulk of the code // in real C#, rather than attempting to build it here. // This means that we have Task <- DefinedTask <- foo_Task. // We also need a module and an assembly to hold the class, so we do that, too. protected override void ExecuteTask() { AssemblyName assemblyName = new AssemblyName(); assemblyName.Name = _taskName + "_Assembly"; AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run); ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(_taskName + "_Module"); // Now we've got an assembly and a module for the task to live in, we can define the actual task class. TypeBuilder typeBuilder = moduleBuilder.DefineType(_taskName + "_Task", TypeAttributes.Public); typeBuilder.SetParent(typeof(DefinedTask)); // It needs a [TaskName] attribute. ConstructorInfo taskNameAttributeConstructor = typeof(TaskNameAttribute).GetConstructor(new Type[] { typeof(string) }); CustomAttributeBuilder taskNameAttributeBuilder = new CustomAttributeBuilder(taskNameAttributeConstructor, new object[] { _taskName }); typeBuilder.SetCustomAttribute(taskNameAttributeBuilder); // We're done. Create it. Type taskType = typeBuilder.CreateType(); // Stash the XML in our static. We'll need it in DefinedTask later. DefinedTaskDefinitions.Add(_taskName, XmlNode); // Hook that up into NAnt. TaskBuilder taskBuilder = new TaskBuilder(taskType.Assembly, taskType.FullName); TypeFactory.TaskBuilders.Add(taskBuilder); }
public static void CompileToAssembly (RegexCompilationInfo[] regexes, AssemblyName aname, CustomAttributeBuilder[] attribs, string resourceFile) { throw new NotImplementedException (); // TODO : Make use of attribs and resourceFile parameters /* AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly (aname, AssemblyBuilderAccess.RunAndSave); ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule("InnerRegexModule",aname.Name); Parser psr = new Parser (); System.Console.WriteLine("CompileToAssembly"); for(int i=0; i < regexes.Length; i++) { System.Console.WriteLine("Compiling expression :" + regexes[i].Pattern); RegularExpression re = psr.ParseRegularExpression (regexes[i].Pattern, regexes[i].Options); // compile CILCompiler cmp = new CILCompiler (modBuilder, i); bool reverse = (regexes[i].Options & RegexOptions.RightToLeft) !=0; re.Compile (cmp, reverse); cmp.Close(); } // Define a runtime class with specified name and attributes. TypeBuilder builder = modBuilder.DefineType("ITest"); builder.CreateType(); asmBuilder.Save(aname.Name); */ }
protected ParameterDescriptor ParseQueueTrigger(JObject trigger, Type triggerParameterType = null) { if (triggerParameterType == null) { triggerParameterType = typeof(string); } ConstructorInfo ctorInfo = typeof(QueueTriggerAttribute).GetConstructor(new Type[] { typeof(string) }); string queueName = (string)trigger["queueName"]; CustomAttributeBuilder attributeBuilder = new CustomAttributeBuilder(ctorInfo, new object[] { queueName }); string parameterName = (string)trigger["name"]; ParameterDescriptor triggerParameter = new ParameterDescriptor { Name = parameterName, Type = triggerParameterType, Attributes = ParameterAttributes.None, CustomAttributes = new Collection<CustomAttributeBuilder> { attributeBuilder } }; return triggerParameter; }
protected RegexDynamicModule(int moduleNum, AssemblyName an, CustomAttributeBuilder[] attribs, String resourceFile) { new ReflectionPermission(PermissionState.Unrestricted).Assert(); try { if (an == null) { an = new AssemblyName(); an.Name = "RegexAssembly" + AppDomain.CurrentDomain.GetHashCode().ToString() + "_" + moduleNum.ToString(); _assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.Run); } else { _assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.RunAndSave); } _module = _assembly.DefineDynamicModule(an.Name + ".dll"); if (attribs != null) { for (int i=0; i<attribs.Length; i++) { _assembly.SetCustomAttribute(attribs[i]); } } if (resourceFile != null) { // unmanaged resources are not supported throw new ArgumentOutOfRangeException("resourceFile"); } } finally { CodeAccessPermission.RevertAssert(); } }
private static TypeBuilder Create(string tableName, List<FieldItem> fields) { //在模块中创建类型 TypeBuilder typeBuilder = GetTypeBuilder(tableName); //设置类型的父类 //typeBuilder.SetParent(typeof(Core)); //创建构造函数 ConstructorBuilder consBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); ILGenerator ctorIL = consBuilder.GetILGenerator(); ctorIL.Emit(OpCodes.Ret); ConstructorInfo classCtorInfo = typeof(DMTableAttribute).GetConstructor(new Type[] { typeof(string), typeof(string), typeof(bool) }); CustomAttributeBuilder attr = new CustomAttributeBuilder( classCtorInfo, new object[] { tableName, "ContentID", true }); typeBuilder.SetCustomAttribute(attr); foreach (var pi in fields) { CreateProperty(typeBuilder, pi.Name, pi.PropertyType); } return typeBuilder; }
public static void Main() { AssemblyName assemblyName = new AssemblyName(); assemblyName.Name = "DynamicllyGeneratedAssembly"; AssemblyBuilder assemblyBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave); ConstructorInfo daCtor = typeof(DebuggableAttribute).GetConstructor(new Type[] { typeof(DebuggableAttribute.DebuggingModes) }); CustomAttributeBuilder daBuilder = new CustomAttributeBuilder(daCtor, new object[] { DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.Default }); assemblyBuilder.SetCustomAttribute(daBuilder); ModuleBuilder module = assemblyBuilder.DefineDynamicModule("DynamicllyGeneratedModule.exe", true); ISymbolDocumentWriter doc = module.DefineDocument(@"Source.txt", Guid.Empty, Guid.Empty, Guid.Empty); TypeBuilder typeBuilder = module.DefineType("DynamicllyGeneratedType", TypeAttributes.Public | TypeAttributes.Class); MethodBuilder methodbuilder = typeBuilder.DefineMethod("Main", MethodAttributes.HideBySig | MethodAttributes.Static | MethodAttributes.Public, typeof(void), new Type[] { typeof(string[]) }); ILGenerator ilGenerator = methodbuilder.GetILGenerator(); ilGenerator.MarkSequencePoint(doc, 1, 1, 1, 100); ilGenerator.Emit(OpCodes.Ldstr, "Hello world!"); MethodInfo infoWriteLine = typeof(System.Console).GetMethod("WriteLine", new Type[] { typeof(string) }); ilGenerator.EmitCall(OpCodes.Call, infoWriteLine, null); ilGenerator.MarkSequencePoint(doc, 2, 1, 2, 100); ilGenerator.Emit(OpCodes.Ret); Type helloWorldType = typeBuilder.CreateType(); System.Diagnostics.Debugger.Break(); helloWorldType.GetMethod("Main").Invoke(null, new string[] { null }); }
public static void AddAttribute(this AssemblyBuilder assemblyBuilder, Type attributeType) { ConstructorInfo attributeCtor = attributeType.GetConstructor(new Type[] { }); CustomAttributeBuilder attributeBuilder = new CustomAttributeBuilder(attributeCtor, new object[] { }); assemblyBuilder.SetCustomAttribute(attributeBuilder); }
internal RegexTypeCompiler(AssemblyName an, CustomAttributeBuilder[] attribs, string resourceFile) { new ReflectionPermission(PermissionState.Unrestricted).Assert(); try { List<CustomAttributeBuilder> assemblyAttributes = new List<CustomAttributeBuilder>(); CustomAttributeBuilder item = new CustomAttributeBuilder(typeof(SecurityTransparentAttribute).GetConstructor(Type.EmptyTypes), new object[0]); assemblyAttributes.Add(item); CustomAttributeBuilder builder2 = new CustomAttributeBuilder(typeof(SecurityRulesAttribute).GetConstructor(new Type[] { typeof(SecurityRuleSet) }), new object[] { SecurityRuleSet.Level2 }); assemblyAttributes.Add(builder2); this._assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(an, AssemblyBuilderAccess.RunAndSave, assemblyAttributes); this._module = this._assembly.DefineDynamicModule(an.Name + ".dll"); if (attribs != null) { for (int i = 0; i < attribs.Length; i++) { this._assembly.SetCustomAttribute(attribs[i]); } } if (resourceFile != null) { this._assembly.DefineUnmanagedResource(resourceFile); } } finally { CodeAccessPermission.RevertAssert(); } }
public void Create_class() { ILGenerator ilGenerator; AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly( new AssemblyName("Scenarios"), AssemblyBuilderAccess.RunAndSave); ModuleBuilder moduleBuilder = asmBuilder.DefineDynamicModule("Scenarios", "Scenarios.dll"); var typeBuilder = moduleBuilder.DefineType("Scenario_Checkout", TypeAttributes.Class | TypeAttributes.Public); var attrBuilder = new CustomAttributeBuilder(typeof(TestFixtureAttribute).GetConstructor(new Type[]{ }), new Object[]{ }); typeBuilder.SetCustomAttribute(attrBuilder); var method = typeBuilder.DefineMethod("ShouldGetLatestChangeset", MethodAttributes.Public); attrBuilder = new CustomAttributeBuilder(typeof(TestAttribute).GetConstructor(new Type[]{ }), new Object[]{ }); method.SetCustomAttribute(attrBuilder); ilGenerator = method.GetILGenerator(); ilGenerator.Emit(OpCodes.Ldstr, "Hello world"); ilGenerator.Emit(OpCodes.Call, typeof(Console).GetMethod("WriteLine", new Type[] { typeof(string)})); //ilGenerator.Emit(OpCodes.Ldc_I4_0); ilGenerator.Emit(OpCodes.Ret); /* var thisType = typeof(CreateCodeAtRuntimeTests); var methodBody = thisType.GetMethod("Haldis").GetMethodBody().GetILAsByteArray(); method.CreateMethodBody(methodBody, methodBody.Length); */ typeBuilder.CreateType(); asmBuilder.Save("Scenarios.dll"); }
public CustAttr(CustomAttributeBuilder customBuilder) { if (customBuilder == null) throw new ArgumentNullException("customBuilder"); m_customBuilder = customBuilder; }
public DynamicAssembly() { int assemblyNumber = Interlocked.Increment(ref _assemblyCount); _assemblyName = new AssemblyName { Name = String.Format("Quokka.DynamicAssembly.N{0}", assemblyNumber) }; string moduleName = AssemblyName.Name; _dynamicClassNamespace = AssemblyName.Name; if (CreateFiles) { _assemblyBuilder = Thread.GetDomain().DefineDynamicAssembly( AssemblyName, AssemblyBuilderAccess.RunAndSave); // Add a debuggable attribute to the assembly saying to disable optimizations // See http://blogs.msdn.com/rmbyers/archive/2005/06/26/432922.aspx Type daType = typeof (DebuggableAttribute); ConstructorInfo daCtor = daType.GetConstructor(new[] {typeof (bool), typeof (bool)}); var daBuilder = new CustomAttributeBuilder(daCtor, new object[] {true, true}); _assemblyBuilder.SetCustomAttribute(daBuilder); _moduleBuilder = _assemblyBuilder.DefineDynamicModule(moduleName); _canSave = true; } else { _assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess.Run); _moduleBuilder = _assemblyBuilder.DefineDynamicModule(moduleName); } }
private static Type CreateDelegateType(BasicSignature signature) { string delTypeName = signature.UniqueName; TypeAttributes typeAttr = TypeAttributes.Class | TypeAttributes.Sealed | TypeAttributes.AnsiClass | TypeAttributes.AutoClass; TypeBuilder del = CppLibrary.interopModule.DefineType (delTypeName, typeAttr, typeof(MulticastDelegate)); if (signature.CallingConvention.HasValue) { ConstructorInfo ufpa = typeof (UnmanagedFunctionPointerAttribute).GetConstructor (new Type [] { typeof (CallingConvention) }); CustomAttributeBuilder unmanagedPointer = new CustomAttributeBuilder (ufpa, new object [] { signature.CallingConvention.Value }); del.SetCustomAttribute (unmanagedPointer); } MethodAttributes ctorAttr = MethodAttributes.RTSpecialName | MethodAttributes.HideBySig | MethodAttributes.Public; ConstructorBuilder ctor = del.DefineConstructor (ctorAttr, CallingConventions.Standard, new Type[] { typeof(object), typeof(System.IntPtr) }); ctor.SetImplementationFlags (MethodImplAttributes.Runtime | MethodImplAttributes.Managed); Type [] parameterTypes = signature.ParameterTypes.ToArray (); MethodAttributes methodAttr = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual; MethodBuilder invokeMethod = del.DefineMethod ("Invoke", methodAttr, signature.ReturnType, parameterTypes); invokeMethod.SetImplementationFlags (MethodImplAttributes.Runtime | MethodImplAttributes.Managed); return del.CreateType (); }
private Type GenerateAnonymousType(ModuleBuilder dynamicTypeModule) { var dynamicType = dynamicTypeModule.DefineType(ClassName, TypeAttributes.BeforeFieldInit | TypeAttributes.Sealed); var builderArray = dynamicType.DefineGenericParameters(GenericClassParameterNames); var fields = new List<FieldBuilder>(); for (var i = 0; i < FieldNames.Length; i++) { var item = dynamicType.DefineField(FieldNames[i], builderArray[i], FieldAttributes.InitOnly | FieldAttributes.Private); var type = typeof(DebuggerBrowsableAttribute); var customBuilder = new CustomAttributeBuilder(type.GetConstructor(new Type[] { typeof(DebuggerBrowsableState) }), new object[] { DebuggerBrowsableState.Never }); item.SetCustomAttribute(customBuilder); fields.Add(item); } var list2 = new List<PropertyBuilder>(); for (var j = 0; j < PropertyNames.Length; j++) { var builder4 = GenerateProperty(dynamicType, PropertyNames[j], fields[j]); // var type = typeof(JsonPropertyAttribute); // var customBuilder2 = new CustomAttributeBuilder(type.GetConstructor(new Type[0]), new object[0]); // builder4.SetCustomAttribute(customBuilder2); list2.Add(builder4); } GenerateClassAttributes(dynamicType, PropertyNames); GenerateConstructor(dynamicType, PropertyNames, fields); GenerateEqualsMethod(dynamicType, fields.ToArray()); GenerateGetHashCodeMethod(dynamicType, fields.ToArray()); GenerateToStringMethod(dynamicType, PropertyNames, fields.ToArray()); return dynamicType.CreateType().MakeGenericType(PropertyTypes); }
public static Type CreateTest() { AppDomain currentDomain = Thread.GetDomain(); AssemblyName assName = new AssemblyName(); assName.Name = "DynamicTest"; AssemblyBuilder assemblyBuilder = currentDomain.DefineDynamicAssembly(assName, AssemblyBuilderAccess.Run); ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("DynamicModule"); TypeBuilder typeBuilder = moduleBuilder.DefineType("DynamicType", TypeAttributes.Public); CustomAttributeBuilder customTypeAttributeBuilder = new CustomAttributeBuilder(typeof(TestClassAttribute).GetConstructors()[0], new object[]{}); typeBuilder.SetCustomAttribute(customTypeAttributeBuilder); MethodBuilder methodBuilder = typeBuilder.DefineMethod("DynamicTestMethod", MethodAttributes.Public, null, new Type[] { }); CustomAttributeBuilder customMethodAttributeBuilder = new CustomAttributeBuilder(typeof(TestMethodAttribute).GetConstructors()[0], new object[] { }); methodBuilder.SetCustomAttribute(customMethodAttributeBuilder); ILGenerator il = methodBuilder.GetILGenerator(); il.EmitWriteLine("Hello world"); il.Emit(OpCodes.Ret); return typeBuilder.CreateType(); }
public void PosTest1() { TypeBuilder typebuilder = GetTypeBuilder(); ConstructorInfo constructorinfo = typeof(ClassCreator).GetConstructor(new Type[] { typeof(string) }); CustomAttributeBuilder cuatbu = new CustomAttributeBuilder(constructorinfo, new object[] { "hello" }); typebuilder.SetCustomAttribute(cuatbu); }
public void TestSetCustomAttribute() { MethodAttributes getMethodAttr = MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig; Type returnType = typeof(int); Type[] ctorParamTypes = new Type[] { typeof(int) }; int expectedValue = _generator.GetInt32(); object[] ctorParamValues = new object[] { expectedValue }; CustomAttributeBuilder customAttrBuilder = new CustomAttributeBuilder( typeof(PBMyAttribute).GetConstructor(ctorParamTypes), ctorParamValues); object[] actualCustomAttrs; actualCustomAttrs = ExecutePosTest( customAttrBuilder, getMethodAttr, returnType, new Type[0], BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Static); Assert.Equal(1, actualCustomAttrs.Length); Assert.True(actualCustomAttrs[0] is PBMyAttribute); Assert.Equal(expectedValue, (actualCustomAttrs[0] as PBMyAttribute).Value); }
public void PosTest1() { string name = "Assembly1"; AssemblyName asmname = new AssemblyName(); asmname.Name = name; AssemblyBuilder asmbuild = AssemblyBuilder.DefineDynamicAssembly(asmname, AssemblyBuilderAccess.Run); ModuleBuilder modbuild = TestLibrary.Utilities.GetModuleBuilder(asmbuild, "Module1"); TypeBuilder tpbuild = modbuild.DefineType("C1"); Type attrType = typeof(TBMyAttribute1); ConstructorInfo ci = attrType.GetConstructors()[0]; FieldInfo fi = attrType.GetField("Field12345"); CustomAttributeBuilder cab = new CustomAttributeBuilder(ci, new object[] { 4 }, new FieldInfo[] { fi }, new object[] { "hello" }); tpbuild.SetCustomAttribute(cab); tpbuild.CreateTypeInfo().AsType(); // VERIFY object[] attribs = tpbuild.GetCustomAttributes(false).Select(a => (object)a).ToArray(); Assert.Equal(1, attribs.Length); TBMyAttribute1 obj = (TBMyAttribute1)attribs[0]; Assert.Equal("hello", obj.Field12345); Assert.Equal(4, obj.m_ctorType2); }
private object[] ExecutePosTest( CustomAttributeBuilder customAttrBuilder, MethodAttributes getMethodAttr, Type returnType, Type[] paramTypes, BindingFlags bindingAttr) { TypeBuilder myTypeBuilder = GetTypeBuilder(TypeAttributes.Class | TypeAttributes.Public); PropertyBuilder myPropertyBuilder = myTypeBuilder.DefineProperty(DynamicPropertyName, PropertyAttributes.HasDefault, returnType, null); myPropertyBuilder.SetCustomAttribute(customAttrBuilder); // Define the "get" accessor method for DynamicPropertyName MethodBuilder myMethodBuilder = myTypeBuilder.DefineMethod(DynamicMethodName, getMethodAttr, returnType, paramTypes); ILGenerator methodILGenerator = myMethodBuilder.GetILGenerator(); methodILGenerator.Emit(OpCodes.Ldarg_0); methodILGenerator.Emit(OpCodes.Ret); // Map the 'get' method created above to our PropertyBuilder myPropertyBuilder.SetGetMethod(myMethodBuilder); Type myType = myTypeBuilder.CreateTypeInfo().AsType(); PropertyInfo myProperty = myType.GetProperty(DynamicPropertyName, bindingAttr); return myProperty.GetCustomAttributes(false).Select(a => (object)a).ToArray(); }
public static CodeCustomAttribute Create (Type attributeType, Type [] ctorArgTypes, CodeLiteral [] ctorArgs, MemberInfo [] members, CodeLiteral [] values) { ArrayList props = new ArrayList (); ArrayList pvalues = new ArrayList (); ArrayList fields = new ArrayList (); ArrayList fvalues = new ArrayList (); for (int i = 0; i < members.Length; i++) { if (members [i] == null) throw new ArgumentException (String.Format ("MemberInfo at {0} was null for type {1}.", i, attributeType)); if (members [i] is PropertyInfo) { props.Add ((PropertyInfo) members [i]); pvalues.Add (values [i].Value); } else { fields.Add ((FieldInfo) members [i]); fvalues.Add (values [i].Value); } } ConstructorInfo ci = attributeType.GetConstructor (ctorArgTypes); CustomAttributeBuilder cab = new CustomAttributeBuilder ( ci, ctorArgs, (PropertyInfo []) props.ToArray (typeof (PropertyInfo)), pvalues.ToArray (), (FieldInfo []) fields.ToArray (typeof (FieldInfo)), fvalues.ToArray ()); CodeCustomAttribute attr = new CodeCustomAttribute ( cab, attributeType, ci, ctorArgs, members, values); return attr; }
public AssemblyAlgorithmIdAttributeTest () { //create a dynamic assembly with the required attribute //and check for the validity dynAsmName.Name = "TestAssembly"; dynAssembly = Thread.GetDomain ().DefineDynamicAssembly ( dynAsmName,AssemblyBuilderAccess.Run ); // Set the required Attribute of the assembly. Type attribute = typeof (AssemblyAlgorithmIdAttribute); ConstructorInfo ctrInfo = attribute.GetConstructor ( new Type [] { typeof (AssemblyHashAlgorithm) } ); CustomAttributeBuilder attrBuilder = new CustomAttributeBuilder ( ctrInfo, new object [1] { AssemblyHashAlgorithm.MD5 } ); dynAssembly.SetCustomAttribute (attrBuilder); object [] attributes = dynAssembly.GetCustomAttributes (true); attr = attributes [0] as AssemblyAlgorithmIdAttribute; }
internal static void Compile(EnumMetadataEnum enumMetadata) { Type type; EnumBuilder builder2; string enumFullName = GetEnumFullName(enumMetadata); if (enumMetadata.UnderlyingType != null) { type = (Type) LanguagePrimitives.ConvertTo(enumMetadata.UnderlyingType, typeof(Type), CultureInfo.InvariantCulture); } else { type = typeof(int); } ModuleBuilder builder = _moduleBuilder.Value; lock (_moduleBuilderUsageLock) { builder2 = builder.DefineEnum(enumFullName, TypeAttributes.Public, type); } if (enumMetadata.BitwiseFlagsSpecified && enumMetadata.BitwiseFlags) { CustomAttributeBuilder customBuilder = new CustomAttributeBuilder(typeof(FlagsAttribute).GetConstructor(Type.EmptyTypes), new object[0]); builder2.SetCustomAttribute(customBuilder); } foreach (EnumMetadataEnumValue value2 in enumMetadata.Value) { string name = value2.Name; object literalValue = LanguagePrimitives.ConvertTo(value2.Value, type, CultureInfo.InvariantCulture); builder2.DefineLiteral(name, literalValue); } builder2.CreateType(); }
/// <summary> /// Copies the EventSourceAttribute from the interfaceType to a CustomAttributeBuilder. /// </summary> /// <param name="type">The interfaceType to copy.</param> /// <returns>A CustomAttributeBuilder that can be assigned to a type.</returns> internal static CustomAttributeBuilder GetEventSourceAttributeBuilder(Type type) { var attribute = type.GetCustomAttribute<EventSourceAttribute>() ?? new EventSourceAttribute(); var implementation = type.GetCustomAttribute<EventSourceImplementationAttribute>() ?? new EventSourceImplementationAttribute(); // by default, we will use a null guid, which will tell EventSource to generate the guid from the name // but if we have already generated this type, we will have to generate a new one string guid = implementation.Guid ?? attribute.Guid ?? null; if (guid == null) { lock (_typesImplemented) { if (_typesImplemented.Contains(type)) guid = Guid.NewGuid().ToString(); else _typesImplemented.Add(type); } } var propertyValues = new object[] { implementation.Name ?? attribute.Name ?? (type.IsGenericType ? type.FullName : type.Name), guid, implementation.LocalizationResources ?? attribute.LocalizationResources ?? null }; CustomAttributeBuilder attributeBuilder = new CustomAttributeBuilder( _eventSourceAttributeConstructor, _emptyParameters, _eventSourceAttributePropertyInfo, propertyValues); return attributeBuilder; }
public void PosTest1() { string testString1 = null; string testString2 = null; int testInt1 = 0; int testInt2 = 0; testString1 = "PosTest1_TestString1"; testString2 = "PosTest1_TestString2"; testInt1 = _generator.GetInt32(); testInt2 = _generator.GetInt32(); Type CustomAttributeBuilderTestType = typeof(CustomAttributeBuilderTest); Type[] ctorParams = new Type[] { typeof(string), typeof(int) }; object[] constructorArgs = new object[] { testString1, testInt1 }; PropertyInfo[] namedProperty = new PropertyInfo[] { CustomAttributeBuilderTestType.GetProperty(PropertyTestInt32Name), CustomAttributeBuilderTestType.GetProperty(PropertyTestStringName), }; object[] propertyValues = new object[] { testInt2, testString2 }; CustomAttributeBuilder cab = new CustomAttributeBuilder( CustomAttributeBuilderTestType.GetConstructor(ctorParams), constructorArgs, namedProperty, propertyValues); Assert.NotNull(cab); PropertyInfo[] verifyFields = new PropertyInfo[] { CustomAttributeBuilderTestType.GetProperty(PropertyTestInt32Name), CustomAttributeBuilderTestType.GetProperty(PropertyTestStringName), CustomAttributeBuilderTestType.GetProperty(PropertyGetOnlyStringName), CustomAttributeBuilderTestType.GetProperty(PropertyGetOnlyIntName) }; object[] verifyFieldValues = new object[] { testInt2, testString2, testString1, testInt1 }; Assert.True(VerifyCustomAttribute(cab, CustomAttributeBuilderTestType, verifyFields, verifyFieldValues)); }
private AssemblyGen() { AssemblyName name = new AssemblyName("Snippets"); CustomAttributeBuilder[] assemblyAttributes = new CustomAttributeBuilder[] { new CustomAttributeBuilder(typeof(SecurityTransparentAttribute).GetConstructor(Type.EmptyTypes), new object[0]) }; this._myAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run, assemblyAttributes); this._myModule = this._myAssembly.DefineDynamicModule(name.Name, false); this._myAssembly.DefineVersionInfoResource(); }
// Use this function if client wishes to build CustomAttribute using CustomAttributeBuilder /// <include file='doc\ParameterBuilder.uex' path='docs/doc[@for="ParameterBuilder.SetCustomAttribute1"]/*' /> public void SetCustomAttribute(CustomAttributeBuilder customBuilder) { if (customBuilder == null) { throw new ArgumentNullException("customBuilder"); } customBuilder.CreateCustomAttribute((ModuleBuilder) (m_methodBuilder .GetModule()), m_pdToken.Token); }
public DynamicProperty(string name, Type type, CustomAttributeBuilder attributeBuilder = null) { if (name == null) throw new ArgumentNullException("name"); if (type == null) throw new ArgumentNullException("type"); this.name = name; this.type = type; this.CustomAttributeBuilder = attributeBuilder; }
public void PosTest1() { FieldBuilder field = TypeBuilder.DefineField("Field_PosTest1", typeof(object), FieldAttributes.Public); ConstructorInfo con = typeof(FBTestAttribute2).GetConstructor(new Type[] { }); CustomAttributeBuilder attribute = new CustomAttributeBuilder(con, new object[] { }); field.SetCustomAttribute(attribute); }
public void PosTest1() { EventBuilder ev = TypeBuilder.DefineEvent("Event_PosTest1", EventAttributes.None, typeof(TestEventHandler)); ConstructorInfo con = typeof(EvBMyAttribute2).GetConstructor(new Type[] { }); CustomAttributeBuilder attribute = new CustomAttributeBuilder(con, new object[] { }); ev.SetCustomAttribute(attribute); }
public CustAttr(CustomAttributeBuilder customBuilder) { if (customBuilder == null) throw new ArgumentNullException(nameof(customBuilder)); Contract.EndContractBlock(); m_customBuilder = customBuilder; }
private static void AddEntityElementIdAnnotation(TypeBuilder typeBuilder, EntityElement entity) { var id = entity.Identity.Id.ToString(); var constructor = typeof(EntityElementIdAttribute).GetConstructors().First(); var customAttributeBuilder = new CustomAttributeBuilder(constructor, new object[] { id }); typeBuilder.SetCustomAttribute(customAttributeBuilder); }
public Object Register(string dllName, string strReturnType, string methodName, string strInputParameterTypes, ref object objParameters) { //COM has no Type class, so do the necessary conversions Type returnType = Type.GetType(strReturnType); //Input Parameter Types int countOfInputParameters = (strInputParameterTypes.Length - 2); Type[] parameterTypes = new Type[countOfInputParameters]; for (int i = 2, j = 0; i < strInputParameterTypes.Length; i++, j++) { parameterTypes[j] = ConvertStringNameToType(strInputParameterTypes[i]); } // Begin to build the dynamic assembly AppDomain domain = AppDomain.CurrentDomain; AssemblyName name = new System.Reflection.AssemblyName("PInvokeAssembly"); AssemblyBuilder assembly = domain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run); ModuleBuilder module = assembly.DefineDynamicModule("PInvokeModule"); TypeBuilder type = module.DefineType("PInvokeType", TypeAttributes.Public | TypeAttributes.BeforeFieldInit); // Define the actual P/Invoke method MethodBuilder method = type.DefineMethod(methodName, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Static | MethodAttributes.PinvokeImpl, returnType, parameterTypes); // Apply the P/Invoke constructor ConstructorInfo ctor = typeof(DllImportAttribute).GetConstructor(new Type [] { typeof(string) }); CustomAttributeBuilder attr = new System.Reflection.Emit.CustomAttributeBuilder(ctor, new Object[] { dllName }); method.SetCustomAttribute(attr); Object[] parameters = ConvertJsArray(objParameters); // Create the temporary type, and invoke the method. Type realType = type.CreateType(); return(realType.InvokeMember(methodName, BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod, null, null, parameters)); }
static bool Regex_CompileToAssembly__RegexCompilationInfo_Array__AssemblyName__CustomAttributeBuilder_Array__String(JSVCall vc, int argc) { int len = argc; if (len == 4) { System.Text.RegularExpressions.RegexCompilationInfo[] arg0 = JSDataExchangeMgr.GetJSArg <System.Text.RegularExpressions.RegexCompilationInfo[]>(() => { int jsObjID = JSApi.getObject((int)JSApi.GetType.Arg); int length = JSApi.getArrayLength(jsObjID); var ret = new System.Text.RegularExpressions.RegexCompilationInfo[length]; for (var i = 0; i < length; i++) { JSApi.getElement(jsObjID, i); ret[i] = (System.Text.RegularExpressions.RegexCompilationInfo)JSMgr.datax.getObject((int)JSApi.GetType.SaveAndRemove); } return(ret); }); System.Reflection.AssemblyName arg1 = (System.Reflection.AssemblyName)JSMgr.datax.getObject((int)JSApi.GetType.Arg); System.Reflection.Emit.CustomAttributeBuilder[] arg2 = JSDataExchangeMgr.GetJSArg <System.Reflection.Emit.CustomAttributeBuilder[]>(() => { int jsObjID = JSApi.getObject((int)JSApi.GetType.Arg); int length = JSApi.getArrayLength(jsObjID); var ret = new System.Reflection.Emit.CustomAttributeBuilder[length]; for (var i = 0; i < length; i++) { JSApi.getElement(jsObjID, i); ret[i] = (System.Reflection.Emit.CustomAttributeBuilder)JSMgr.datax.getObject((int)JSApi.GetType.SaveAndRemove); } return(ret); }); System.String arg3 = (System.String)JSApi.getStringS((int)JSApi.GetType.Arg); System.Text.RegularExpressions.Regex.CompileToAssembly(arg0, arg1, arg2, arg3); } return(true); }
public Object InvokeWin32(string dllName, Type returnType, string methodName, Type[] parameterTypes, Object[] parameters) { // Begin to build the dynamic assembly AppDomain domain = AppDomain.CurrentDomain; AssemblyName name = new System.Reflection.AssemblyName("PInvokeAssembly"); AssemblyBuilder assembly = domain.DefineDynamicAssembly(name, AssemblyBuilderAccess.Run); ModuleBuilder module = assembly.DefineDynamicModule("PInvokeModule"); TypeBuilder type = module.DefineType("PInvokeType", TypeAttributes.Public | TypeAttributes.BeforeFieldInit); // Define the actual P/Invoke method MethodBuilder method = type.DefineMethod(methodName, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Static | MethodAttributes.PinvokeImpl, returnType, parameterTypes); // Apply the P/Invoke constructor ConstructorInfo ctor = typeof(DllImportAttribute).GetConstructor(new Type [] { typeof(string) }); CustomAttributeBuilder attr = new System.Reflection.Emit.CustomAttributeBuilder(ctor, new Object[] { dllName }); method.SetCustomAttribute(attr); // Create the temporary type, and invoke the method. Type realType = type.CreateType(); return(realType.InvokeMember(methodName, BindingFlags.Public | BindingFlags.Static | BindingFlags.InvokeMethod, null, null, parameters)); }
/// <summary> /// Generate the declaration for the IgnoresAccessChecksToAttribute type. /// This attribute will be both defined and used in the dynamic assembly. /// Each usage identifies the name of the assembly containing non-public /// types the dynamic assembly needs to access. Normally those types /// would be inaccessible, but this attribute allows them to be visible. /// It works like a reverse InternalsVisibleToAttribute. /// This method returns the ConstructorInfo of the generated attribute. /// </summary> public static ConstructorInfo AddToModule(ModuleBuilder mb) { TypeBuilder attributeTypeBuilder = mb.DefineType("System.Runtime.CompilerServices.IgnoresAccessChecksToAttribute", TypeAttributes.Public | TypeAttributes.Class, typeof(Attribute)); // Create backing field as: // private string assemblyName; FieldBuilder assemblyNameField = attributeTypeBuilder.DefineField("assemblyName", typeof(string), FieldAttributes.Private); // Create ctor as: // public IgnoresAccessChecksToAttribute(string) ConstructorBuilder constructorBuilder = attributeTypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.HasThis, new Type[] { assemblyNameField.FieldType }); ILGenerator il = constructorBuilder.GetILGenerator(); // Create ctor body as: // this.assemblyName = {ctor parameter 0} il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldarg, 1); il.Emit(OpCodes.Stfld, assemblyNameField); // return il.Emit(OpCodes.Ret); // Define property as: // public string AssemblyName {get { return this.assemblyName; } } _ = attributeTypeBuilder.DefineProperty( "AssemblyName", PropertyAttributes.None, CallingConventions.HasThis, returnType: typeof(string), parameterTypes: null); MethodBuilder getterMethodBuilder = attributeTypeBuilder.DefineMethod( "get_AssemblyName", MethodAttributes.Public, CallingConventions.HasThis, returnType: typeof(string), parameterTypes: null); // Generate body: // return this.assemblyName; il = getterMethodBuilder.GetILGenerator(); il.Emit(OpCodes.Ldarg_0); il.Emit(OpCodes.Ldfld, assemblyNameField); il.Emit(OpCodes.Ret); // Generate the AttributeUsage attribute for this attribute type: // [AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)] TypeInfo attributeUsageTypeInfo = typeof(AttributeUsageAttribute).GetTypeInfo(); // Find the ctor that takes only AttributeTargets ConstructorInfo attributeUsageConstructorInfo = attributeUsageTypeInfo.DeclaredConstructors .Single(c => c.GetParameters().Length == 1 && c.GetParameters()[0].ParameterType == typeof(AttributeTargets)); // Find the property to set AllowMultiple PropertyInfo allowMultipleProperty = attributeUsageTypeInfo.DeclaredProperties .Single(f => string.Equals(f.Name, "AllowMultiple")); // Create a builder to construct the instance via the ctor and property CustomAttributeBuilder customAttributeBuilder = new CustomAttributeBuilder(attributeUsageConstructorInfo, new object[] { AttributeTargets.Assembly }, new PropertyInfo[] { allowMultipleProperty }, new object[] { true }); // Attach this attribute instance to the newly defined attribute type attributeTypeBuilder.SetCustomAttribute(customAttributeBuilder); // Make the TypeInfo real so the constructor can be used. return(attributeTypeBuilder.CreateTypeInfo() !.DeclaredConstructors.Single()); }
public void SetCustomAttribute(CustomAttributeBuilder !customBuilder) { CodeContract.Requires(customBuilder != null); }
private void Initialize(ConstructorInfo con, object[] constructorArgs, PropertyInfo[] namedProperties, object[] propertyValues, FieldInfo[] namedFields, object[] fieldValues) { this.ctor = con; if (con == null) { throw new ArgumentNullException("con"); } if (constructorArgs == null) { throw new ArgumentNullException("constructorArgs"); } if (namedProperties == null) { throw new ArgumentNullException("namedProperties"); } if (propertyValues == null) { throw new ArgumentNullException("propertyValues"); } if (namedFields == null) { throw new ArgumentNullException("namedFields"); } if (fieldValues == null) { throw new ArgumentNullException("fieldValues"); } if (con.GetParameterCount() != constructorArgs.Length) { throw new ArgumentException("Parameter count does not match passed in argument value count."); } if (namedProperties.Length != propertyValues.Length) { throw new ArgumentException("Array lengths must be the same.", "namedProperties, propertyValues"); } if (namedFields.Length != fieldValues.Length) { throw new ArgumentException("Array lengths must be the same.", "namedFields, fieldValues"); } if ((con.Attributes & MethodAttributes.Static) == MethodAttributes.Static || (con.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Private) { throw new ArgumentException("Cannot have private or static constructor."); } Type declaringType = this.ctor.DeclaringType; int num = 0; foreach (FieldInfo fieldInfo in namedFields) { Type declaringType2 = fieldInfo.DeclaringType; if (!this.IsValidType(declaringType2)) { throw new ArgumentException("Field '" + fieldInfo.Name + "' does not have a valid type."); } if (declaringType != declaringType2 && !declaringType2.IsSubclassOf(declaringType) && !declaringType.IsSubclassOf(declaringType2)) { throw new ArgumentException("Field '" + fieldInfo.Name + "' does not belong to the same class as the constructor"); } if (fieldValues[num] != null && !(fieldInfo.FieldType is TypeBuilder) && !fieldInfo.FieldType.IsEnum && !fieldInfo.FieldType.IsInstanceOfType(fieldValues[num]) && !fieldInfo.FieldType.IsArray) { throw new ArgumentException(string.Concat(new object[] { "Value of field '", fieldInfo.Name, "' does not match field type: ", fieldInfo.FieldType })); } num++; } num = 0; foreach (PropertyInfo propertyInfo in namedProperties) { if (!propertyInfo.CanWrite) { throw new ArgumentException("Property '" + propertyInfo.Name + "' does not have a setter."); } Type declaringType3 = propertyInfo.DeclaringType; if (!this.IsValidType(declaringType3)) { throw new ArgumentException("Property '" + propertyInfo.Name + "' does not have a valid type."); } if (declaringType != declaringType3 && !declaringType3.IsSubclassOf(declaringType) && !declaringType.IsSubclassOf(declaringType3)) { throw new ArgumentException("Property '" + propertyInfo.Name + "' does not belong to the same class as the constructor"); } if (propertyValues[num] != null && !(propertyInfo.PropertyType is TypeBuilder) && !propertyInfo.PropertyType.IsEnum && !propertyInfo.PropertyType.IsInstanceOfType(propertyValues[num]) && !propertyInfo.PropertyType.IsArray) { throw new ArgumentException(string.Concat(new object[] { "Value of property '", propertyInfo.Name, "' does not match property type: ", propertyInfo.PropertyType, " -> ", propertyValues[num] })); } num++; } num = 0; foreach (ParameterInfo parameterInfo in CustomAttributeBuilder.GetParameters(con)) { if (parameterInfo != null) { Type parameterType = parameterInfo.ParameterType; if (!this.IsValidType(parameterType)) { throw new ArgumentException("Argument " + num + " does not have a valid type."); } if (constructorArgs[num] != null && !(parameterType is TypeBuilder) && !parameterType.IsEnum && !parameterType.IsInstanceOfType(constructorArgs[num]) && !parameterType.IsArray) { throw new ArgumentException(string.Concat(new object[] { "Value of argument ", num, " does not match parameter type: ", parameterType, " -> ", constructorArgs[num] })); } } num++; } this.data = CustomAttributeBuilder.GetBlob(declaringType.Assembly, con, constructorArgs, namedProperties, propertyValues, namedFields, fieldValues); }
internal static UnmanagedMarshal get_umarshal(CustomAttributeBuilder customBuilder, bool is_field) { byte[] array = customBuilder.Data; UnmanagedType elemType = (UnmanagedType)80; int num = -1; int sizeParamIndex = -1; bool flag = false; string text = null; Type typeref = null; string cookie = string.Empty; int num2 = (int)array[2]; num2 |= (int)array[3] << 8; string fullName = CustomAttributeBuilder.GetParameters(customBuilder.Ctor)[0].ParameterType.FullName; int num3 = 6; if (fullName == "System.Int16") { num3 = 4; } int num4 = (int)array[num3++]; num4 |= (int)array[num3++] << 8; int i = 0; while (i < num4) { num3++; int num5 = (int)array[num3++]; if (num5 == 85) { int num6 = CustomAttributeBuilder.decode_len(array, num3, out num3); CustomAttributeBuilder.string_from_bytes(array, num3, num6); num3 += num6; } int num7 = CustomAttributeBuilder.decode_len(array, num3, out num3); string text2 = CustomAttributeBuilder.string_from_bytes(array, num3, num7); num3 += num7; string text3 = text2; if (text3 != null) { if (CustomAttributeBuilder.< > f__switch$map1C == null) { CustomAttributeBuilder.< > f__switch$map1C = new Dictionary <string, int>(9) { { "ArraySubType", 0 }, { "SizeConst", 1 }, { "SafeArraySubType", 2 }, { "IidParameterIndex", 3 }, { "SafeArrayUserDefinedSubType", 4 }, { "SizeParamIndex", 5 }, { "MarshalType", 6 }, { "MarshalTypeRef", 7 }, { "MarshalCookie", 8 } }; } int num8; if (CustomAttributeBuilder.< > f__switch$map1C.TryGetValue(text3, out num8)) { switch (num8) { case 0: { int num9 = (int)array[num3++]; num9 |= (int)array[num3++] << 8; num9 |= (int)array[num3++] << 16; num9 |= (int)array[num3++] << 24; elemType = (UnmanagedType)num9; break; } case 1: { int num9 = (int)array[num3++]; num9 |= (int)array[num3++] << 8; num9 |= (int)array[num3++] << 16; num9 |= (int)array[num3++] << 24; num = num9; flag = true; break; } case 2: { int num9 = (int)array[num3++]; num9 |= (int)array[num3++] << 8; num9 |= (int)array[num3++] << 16; num9 |= (int)array[num3++] << 24; elemType = (UnmanagedType)num9; break; } case 3: num3 += 4; break; case 4: num7 = CustomAttributeBuilder.decode_len(array, num3, out num3); CustomAttributeBuilder.string_from_bytes(array, num3, num7); num3 += num7; break; case 5: { int num9 = (int)array[num3++]; num9 |= (int)array[num3++] << 8; sizeParamIndex = num9; flag = true; break; } case 6: num7 = CustomAttributeBuilder.decode_len(array, num3, out num3); text = CustomAttributeBuilder.string_from_bytes(array, num3, num7); num3 += num7; break; case 7: num7 = CustomAttributeBuilder.decode_len(array, num3, out num3); text = CustomAttributeBuilder.string_from_bytes(array, num3, num7); typeref = Type.GetType(text); num3 += num7; break; case 8: num7 = CustomAttributeBuilder.decode_len(array, num3, out num3); cookie = CustomAttributeBuilder.string_from_bytes(array, num3, num7); num3 += num7; break; default: goto IL_34F; } i++; continue; } } IL_34F: throw new Exception("Unknown MarshalAsAttribute field: " + text2); } UnmanagedType unmanagedType = (UnmanagedType)num2; switch (unmanagedType) { case UnmanagedType.LPArray: if (flag) { return(UnmanagedMarshal.DefineLPArrayInternal(elemType, num, sizeParamIndex)); } return(UnmanagedMarshal.DefineLPArray(elemType)); default: if (unmanagedType == UnmanagedType.SafeArray) { return(UnmanagedMarshal.DefineSafeArray(elemType)); } if (unmanagedType != UnmanagedType.ByValArray) { if (unmanagedType != UnmanagedType.ByValTStr) { return(UnmanagedMarshal.DefineUnmanagedMarshal((UnmanagedType)num2)); } return(UnmanagedMarshal.DefineByValTStr(num)); } else { if (!is_field) { throw new ArgumentException("Specified unmanaged type is only valid on fields"); } return(UnmanagedMarshal.DefineByValArray(num)); } break; case UnmanagedType.CustomMarshaler: return(UnmanagedMarshal.DefineCustom(typeref, cookie, text, Guid.Empty)); } }
internal static CustomAttributeBuilder.CustomAttributeInfo decode_cattr(CustomAttributeBuilder customBuilder) { byte[] array = customBuilder.Data; ConstructorInfo constructorInfo = customBuilder.Ctor; int num = 0; CustomAttributeBuilder.CustomAttributeInfo result = default(CustomAttributeBuilder.CustomAttributeInfo); if (array.Length < 2) { throw new Exception("Custom attr length is only '" + array.Length + "'"); } if (array[0] != 1 || array[1] != 0) { throw new Exception("Prolog invalid"); } num = 2; ParameterInfo[] parameters = CustomAttributeBuilder.GetParameters(constructorInfo); result.ctor = constructorInfo; result.ctorArgs = new object[parameters.Length]; for (int i = 0; i < parameters.Length; i++) { result.ctorArgs[i] = CustomAttributeBuilder.decode_cattr_value(parameters[i].ParameterType, array, num, out num); } int num2 = (int)array[num] + (int)array[num + 1] * 256; num += 2; result.namedParamNames = new string[num2]; result.namedParamValues = new object[num2]; for (int j = 0; j < num2; j++) { int num3 = (int)array[num++]; int num4 = (int)array[num++]; string text = null; if (num4 == 85) { int num5 = CustomAttributeBuilder.decode_len(array, num, out num); text = CustomAttributeBuilder.string_from_bytes(array, num, num5); num += num5; } int num6 = CustomAttributeBuilder.decode_len(array, num, out num); string text2 = CustomAttributeBuilder.string_from_bytes(array, num, num6); result.namedParamNames[j] = text2; num += num6; if (num3 != 83) { throw new Exception("Unknown named type: " + num3); } FieldInfo field = constructorInfo.DeclaringType.GetField(text2, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); if (field == null) { throw new Exception(string.Concat(new object[] { "Custom attribute type '", constructorInfo.DeclaringType, "' doesn't contain a field named '", text2, "'" })); } object obj = CustomAttributeBuilder.decode_cattr_value(field.FieldType, array, num, out num); if (text != null) { Type type = Type.GetType(text); obj = Enum.ToObject(type, obj); } result.namedParamValues[j] = obj; } return(result); }
unsafe static void Main(string[] args) { Console.WriteLine("[*] Searching the Vaults..."); var OSVersion = Environment.OSVersion.Version; var OSMajor = OSVersion.Major; var OSMinor = OSVersion.Minor; /* Begin PInvoke Region */ var DynAssembly = new System.Reflection.AssemblyName("VaultUtil"); var AssemblyBuilder = System.AppDomain.CurrentDomain.DefineDynamicAssembly(DynAssembly, System.Reflection.Emit.AssemblyBuilderAccess.Run); var ModuleBuilder = AssemblyBuilder.DefineDynamicModule("VaultUtil", false); var EnumBuilder = ModuleBuilder.DefineEnum("VaultLib.VAULT_ELEMENT_TYPE", TypeAttributes.Public, typeof(Int32)); EnumBuilder.DefineLiteral("Undefined", -1); EnumBuilder.DefineLiteral("Boolean", 0); EnumBuilder.DefineLiteral("Short", 1); EnumBuilder.DefineLiteral("UnsignedShort", 2); EnumBuilder.DefineLiteral("Int", 3); EnumBuilder.DefineLiteral("UnsignedInt", 4); EnumBuilder.DefineLiteral("Double", 5); EnumBuilder.DefineLiteral("Guid", 6); EnumBuilder.DefineLiteral("String", 7); EnumBuilder.DefineLiteral("ByteArray", 8); EnumBuilder.DefineLiteral("TimeStamp", 9); EnumBuilder.DefineLiteral("ProtectedArray", 10); EnumBuilder.DefineLiteral("Attribute", 11); EnumBuilder.DefineLiteral("Sid", 12); EnumBuilder.DefineLiteral("Last", 13); var VAULT_ELEMENT_TYPE = EnumBuilder.CreateType(); EnumBuilder = ModuleBuilder.DefineEnum("VaultLib.VAULT_SCHEMA_ELEMENT_ID", TypeAttributes.Public, typeof(Int32)); EnumBuilder.DefineLiteral("Illegal", 0); EnumBuilder.DefineLiteral("Resource", 1); EnumBuilder.DefineLiteral("Identity", 2); EnumBuilder.DefineLiteral("Authenticator", 3); EnumBuilder.DefineLiteral("Tag", 4); EnumBuilder.DefineLiteral("PackageSid", 5); EnumBuilder.DefineLiteral("AppStart", 100); EnumBuilder.DefineLiteral("AppEnd", 10000); var VAULT_SCHEMA_ELEMENT_ID = EnumBuilder.CreateType(); Type[] LayoutConstructorArgs = new Type[] { typeof(System.Runtime.InteropServices.LayoutKind) }; ConstructorInfo LayoutConstructor = typeof(System.Runtime.InteropServices.StructLayoutAttribute).GetConstructor(LayoutConstructorArgs); var CharsetField = typeof(System.Runtime.InteropServices.StructLayoutAttribute).GetField("CharSet"); Object[] ConstructorArgs = new Object[] { System.Runtime.InteropServices.LayoutKind.Explicit }; FieldInfo[] FieldInfoArgs = new FieldInfo[] { CharsetField }; Object[] FieldValueArgs = new Object[] { System.Runtime.InteropServices.CharSet.Ansi }; var StructLayoutCustomAttribute = new System.Reflection.Emit.CustomAttributeBuilder( LayoutConstructor, ConstructorArgs, FieldInfoArgs, FieldValueArgs ); // VAULT_ITEM var TypeBuilder = ModuleBuilder.DefineType( "VaultLib.VAULT_ITEM", TypeAttributes.AutoLayout | TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.SequentialLayout | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit, typeof(Object), (int)System.Reflection.Emit.PackingSize.Size4 ); TypeBuilder.DefineField("SchemaId", typeof(System.Guid), FieldAttributes.Public); TypeBuilder.DefineField("pszCredentialFriendlyName", typeof(System.IntPtr), FieldAttributes.Public); TypeBuilder.DefineField("pResourceElement", typeof(IntPtr), FieldAttributes.Public); TypeBuilder.DefineField("pIdentityElement", typeof(IntPtr), FieldAttributes.Public); TypeBuilder.DefineField("pAuthenticatorElement", typeof(IntPtr), FieldAttributes.Public); if (OSMajor >= 6 && OSMinor >= 2) { TypeBuilder.DefineField("pPackageSid", typeof(IntPtr), FieldAttributes.Public); } TypeBuilder.DefineField("LastModified", typeof(UInt64), FieldAttributes.Public); TypeBuilder.DefineField("dwFlags", typeof(UInt32), FieldAttributes.Public); TypeBuilder.DefineField("dwPropertiesCount", typeof(UInt32), FieldAttributes.Public); TypeBuilder.DefineField("pPropertyElements", typeof(IntPtr), FieldAttributes.Public); var VAULT_ITEM = TypeBuilder.CreateType(); // VAULT_ITEM_ELEMENT TypeBuilder = ModuleBuilder.DefineType( "VaultLib.VAULT_ITEM_ELEMENT", TypeAttributes.AutoLayout | TypeAttributes.AnsiClass | TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.SequentialLayout | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit, typeof(object), (int)System.Reflection.Emit.PackingSize.Size4 ); TypeBuilder.SetCustomAttribute(StructLayoutCustomAttribute); TypeBuilder.DefineField("SchemaElementId", VAULT_SCHEMA_ELEMENT_ID, FieldAttributes.Public).SetOffset(0); TypeBuilder.DefineField("Type", VAULT_ELEMENT_TYPE, FieldAttributes.Public).SetOffset(8); var VAULT_ITEM_ELEMENT = TypeBuilder.CreateType(); // Vaultcli TypeBuilder = ModuleBuilder.DefineType("VaultLib.Vaultcli", TypeAttributes.Public | TypeAttributes.Class); Type[] PInvokeTypeArgs = new Type[] { typeof(Guid *), typeof(UInt32), typeof(IntPtr *) }; TypeBuilder.DefinePInvokeMethod( "VaultOpenVault", "vaultcli.dll", MethodAttributes.Public | MethodAttributes.Static, System.Reflection.CallingConventions.Standard, typeof(Int32), PInvokeTypeArgs, System.Runtime.InteropServices.CallingConvention.Winapi, System.Runtime.InteropServices.CharSet.Auto ); PInvokeTypeArgs = new Type[] { typeof(IntPtr *) }; TypeBuilder.DefinePInvokeMethod( "VaultCloseVault", "vaultcli.dll", MethodAttributes.Public | MethodAttributes.Static, System.Reflection.CallingConventions.Standard, typeof(Int32), PInvokeTypeArgs, System.Runtime.InteropServices.CallingConvention.Winapi, System.Runtime.InteropServices.CharSet.Auto ); TypeBuilder.DefinePInvokeMethod( "VaultFree", "vaultcli.dll", MethodAttributes.Public | MethodAttributes.Static, System.Reflection.CallingConventions.Standard, typeof(Int32), PInvokeTypeArgs, System.Runtime.InteropServices.CallingConvention.Winapi, System.Runtime.InteropServices.CharSet.Auto ); PInvokeTypeArgs = new Type[] { typeof(Int32), typeof(Int32 *), typeof(IntPtr *) }; TypeBuilder.DefinePInvokeMethod( "VaultEnumerateVaults", "vaultcli.dll", MethodAttributes.Public | MethodAttributes.Static, System.Reflection.CallingConventions.Standard, typeof(Int32), PInvokeTypeArgs, System.Runtime.InteropServices.CallingConvention.Winapi, System.Runtime.InteropServices.CharSet.Auto ); PInvokeTypeArgs = new Type[] { typeof(IntPtr), typeof(Int32), typeof(Int32 *), typeof(IntPtr *) }; TypeBuilder.DefinePInvokeMethod( "VaultEnumerateItems", "vaultcli.dll", MethodAttributes.Public | MethodAttributes.Static, System.Reflection.CallingConventions.Standard, typeof(Int32), PInvokeTypeArgs, System.Runtime.InteropServices.CallingConvention.Winapi, System.Runtime.InteropServices.CharSet.Auto ); if (OSMajor >= 6 && OSMinor >= 2) { PInvokeTypeArgs = new Type[] { typeof(IntPtr), typeof(Guid *), typeof(IntPtr), typeof(IntPtr), typeof(IntPtr), typeof(IntPtr), typeof(Int32), typeof(IntPtr *) }; } else { PInvokeTypeArgs = new Type[] { typeof(IntPtr), typeof(Guid *), typeof(IntPtr), typeof(IntPtr), typeof(IntPtr), typeof(Int32), typeof(IntPtr *) }; } TypeBuilder.DefinePInvokeMethod( "VaultGetItem", "vaultcli.dll", MethodAttributes.Public | MethodAttributes.Static, System.Reflection.CallingConventions.Standard, typeof(Int32), PInvokeTypeArgs, System.Runtime.InteropServices.CallingConvention.Winapi, System.Runtime.InteropServices.CharSet.Auto ); /* Define the VaultCli and Methods we'll be calling */ Type VaultCli = TypeBuilder.CreateType(); MethodInfo VaultEnumerateVaults = VaultCli.GetMethod("VaultEnumerateVaults"); MethodInfo VaultOpenVault = VaultCli.GetMethod("VaultOpenVault"); MethodInfo VaultEnumerateItems = VaultCli.GetMethod("VaultEnumerateItems"); MethodInfo VaultGetItem = VaultCli.GetMethod("VaultGetItem"); /* End PInvoke Region */ /* Helper function to extract the ItemValue field from a VAULT_ITEM_ELEMENT struct */ object GetVaultElementValue(IntPtr vaultElementPtr) { object results; object partialElement = System.Runtime.InteropServices.Marshal.PtrToStructure(vaultElementPtr, VAULT_ITEM_ELEMENT); FieldInfo partialElementInfo = partialElement.GetType().GetField("Type"); var partialElementType = partialElementInfo.GetValue(partialElement); IntPtr elementPtr = (IntPtr)(vaultElementPtr.ToInt64() + 16); switch ((int)partialElementType) { case 7: // VAULT_ELEMENT_TYPE == String; These are the plaintext passwords! IntPtr StringPtr = System.Runtime.InteropServices.Marshal.ReadIntPtr(elementPtr); results = System.Runtime.InteropServices.Marshal.PtrToStringUni(StringPtr); break; case 0: // VAULT_ELEMENT_TYPE == bool results = System.Runtime.InteropServices.Marshal.ReadByte(elementPtr); results = (bool)results; break; case 1: // VAULT_ELEMENT_TYPE == Short results = System.Runtime.InteropServices.Marshal.ReadInt16(elementPtr); break; case 2: // VAULT_ELEMENT_TYPE == Unsigned Short results = System.Runtime.InteropServices.Marshal.ReadInt16(elementPtr); break; case 3: // VAULT_ELEMENT_TYPE == Int results = System.Runtime.InteropServices.Marshal.ReadInt32(elementPtr); break; case 4: // VAULT_ELEMENT_TYPE == Unsigned Int results = System.Runtime.InteropServices.Marshal.ReadInt32(elementPtr); break; case 5: // VAULT_ELEMENT_TYPE == Double results = System.Runtime.InteropServices.Marshal.PtrToStructure(elementPtr, typeof(Double)); break; case 6: // VAULT_ELEMENT_TYPE == GUID results = System.Runtime.InteropServices.Marshal.PtrToStructure(elementPtr, typeof(Guid)); break; case 12: // VAULT_ELEMENT_TYPE == Sid IntPtr sidPtr = System.Runtime.InteropServices.Marshal.ReadIntPtr(elementPtr); var sidObject = new System.Security.Principal.SecurityIdentifier(sidPtr); results = sidObject.Value; break; default: /* Several VAULT_ELEMENT_TYPES are currently unimplemented according to * Lord Graeber. Thus we do not implement them. */ results = null; break; } return(results); } /* End helper function */ Int32 vaultCount = 0; Int32 *vaultCountPtr = &vaultCount; object boxedVaultCountPtr = Pointer.Box(vaultCountPtr, typeof(Int32 *)); IntPtr vaultGuidPtr = IntPtr.Zero; // Lord help me for this naming convention IntPtr *vaultGuidPtrPtr = &vaultGuidPtr; object boxedVaultGuidPtr = Pointer.Box(vaultGuidPtrPtr, typeof(IntPtr *)); object[] vaultEnumVaultArgs = { 0, boxedVaultCountPtr, boxedVaultGuidPtr }; var result = VaultEnumerateVaults.Invoke(null, vaultEnumVaultArgs); //var result = CallVaultEnumerateVaults(VaultEnum, 0, ref vaultCount, ref vaultGuidPtr); if ((int)result != 0) { throw new Exception("[ERROR] Unable to enumerate vaults. Error (0x" + result.ToString() + ")"); } // Create dictionary to translate Guids to human readable elements IntPtr guidAddress = vaultGuidPtr; Dictionary <Guid, string> vaultSchema = new Dictionary <Guid, string>(); vaultSchema.Add(new Guid("2F1A6504-0641-44CF-8BB5-3612D865F2E5"), "Windows Secure Note"); vaultSchema.Add(new Guid("3CCD5499-87A8-4B10-A215-608888DD3B55"), "Windows Web Password Credential"); vaultSchema.Add(new Guid("154E23D0-C644-4E6F-8CE6-5069272F999F"), "Windows Credential Picker Protector"); vaultSchema.Add(new Guid("4BF4C442-9B8A-41A0-B380-DD4A704DDB28"), "Web Credentials"); vaultSchema.Add(new Guid("77BC582B-F0A6-4E15-4E80-61736B6F3B29"), "Windows Credentials"); vaultSchema.Add(new Guid("E69D7838-91B5-4FC9-89D5-230D4D4CC2BC"), "Windows Domain Certificate Credential"); vaultSchema.Add(new Guid("3E0E35BE-1B77-43E7-B873-AED901B6275B"), "Windows Domain Password Credential"); vaultSchema.Add(new Guid("3C886FF3-2669-4AA2-A8FB-3F6759A77548"), "Windows Extended Credential"); vaultSchema.Add(new Guid("00000000-0000-0000-0000-000000000000"), null); for (int i = 0; i < vaultCount; i++) { // Open vault block object vaultGuidString = System.Runtime.InteropServices.Marshal.PtrToStructure(guidAddress, typeof(Guid)); Guid vaultGuid = new Guid(vaultGuidString.ToString()); Guid * tmpVaultGuidPtr = &vaultGuid; boxedVaultGuidPtr = Pointer.Box(tmpVaultGuidPtr, typeof(Guid *)); guidAddress = (IntPtr)(guidAddress.ToInt64() + System.Runtime.InteropServices.Marshal.SizeOf(typeof(Guid))); IntPtr vaultHandle = IntPtr.Zero; IntPtr *vaultHandlePtr = &vaultHandle; object boxedVaultHandlePtr = Pointer.Box(vaultHandlePtr, typeof(IntPtr *)); string vaultType; if (vaultSchema.ContainsKey(vaultGuid)) { vaultType = vaultSchema[vaultGuid]; } else { vaultType = vaultGuid.ToString(); } object[] openVaultArgs = { boxedVaultGuidPtr, (UInt32)0, boxedVaultHandlePtr }; result = VaultOpenVault.Invoke(null, openVaultArgs); if ((int)result != 0) { throw new Exception("Unable to open the following vault: " + vaultType + ". Error: 0x" + result.ToString()); } // Vault opened successfully! Continue. // Fetch all items within Vault int vaultItemCount = 0; int * vaultItemCountPtr = &vaultItemCount; object boxedVaultItemCountPtr = Pointer.Box(vaultItemCountPtr, typeof(int *)); IntPtr vaultItemPtr = IntPtr.Zero; IntPtr * vaultItemPtrPtr = &vaultItemPtr; object boxedVaultItemPtr = Pointer.Box(vaultItemPtrPtr, typeof(IntPtr *)); object[] vaultEnumerateItemsArgs = { vaultHandle, 512, boxedVaultItemCountPtr, boxedVaultItemPtr }; result = VaultEnumerateItems.Invoke(null, vaultEnumerateItemsArgs); if ((int)result != 0) { throw new Exception("[ERROR] Unable to enumerate vault items from the following vault: " + vaultType + ". Error 0x" + result.ToString()); } var structAddress = vaultItemPtr; if (vaultItemCount > 0) { // For each vault item... for (int j = 1; j <= vaultItemCount; j++) { // Begin fetching vault item... var currentItem = System.Runtime.InteropServices.Marshal.PtrToStructure(structAddress, VAULT_ITEM); structAddress = (IntPtr)(structAddress.ToInt64() + System.Runtime.InteropServices.Marshal.SizeOf(VAULT_ITEM)); IntPtr passwordVaultItem = IntPtr.Zero; IntPtr *passwordVaultPtr = &passwordVaultItem; object boxedPasswordVaultPtr = Pointer.Box(passwordVaultPtr, typeof(IntPtr *)); // Field Info retrieval FieldInfo schemaIdInfo = currentItem.GetType().GetField("SchemaId"); Guid schemaId = new Guid(schemaIdInfo.GetValue(currentItem).ToString()); Guid * schemaIdPtr = &schemaId; object boxedSchemaIdPtr = Pointer.Box(schemaIdPtr, typeof(Guid *)); FieldInfo pResourceElementInfo = currentItem.GetType().GetField("pResourceElement"); IntPtr pResourceElement = (IntPtr)pResourceElementInfo.GetValue(currentItem); FieldInfo pIdentityElementInfo = currentItem.GetType().GetField("pIdentityElement"); IntPtr pIdentityElement = (IntPtr)pIdentityElementInfo.GetValue(currentItem); FieldInfo dateTimeInfo = currentItem.GetType().GetField("LastModified"); UInt64 lastModified = (UInt64)dateTimeInfo.GetValue(currentItem); object[] vaultGetItemArgs; if (OSMajor >= 6 && OSMinor >= 2) { vaultGetItemArgs = new object[8]; vaultGetItemArgs[0] = vaultHandle; vaultGetItemArgs[1] = boxedSchemaIdPtr; vaultGetItemArgs[2] = pResourceElement; vaultGetItemArgs[3] = pIdentityElement; // Newer versions have package sid FieldInfo pPackageSidInfo = currentItem.GetType().GetField("pPackageSid"); IntPtr pPackageSid = (IntPtr)pPackageSidInfo.GetValue(currentItem); vaultGetItemArgs[4] = pPackageSid; vaultGetItemArgs[5] = IntPtr.Zero; vaultGetItemArgs[6] = 0; vaultGetItemArgs[7] = boxedPasswordVaultPtr; } else { vaultGetItemArgs = new object[7]; vaultGetItemArgs[0] = vaultHandle; vaultGetItemArgs[1] = boxedSchemaIdPtr; vaultGetItemArgs[2] = pResourceElement; vaultGetItemArgs[3] = pIdentityElement; vaultGetItemArgs[4] = IntPtr.Zero; vaultGetItemArgs[5] = 0; vaultGetItemArgs[6] = boxedPasswordVaultPtr; } // Where the actual fetching happens result = VaultGetItem.Invoke(null, vaultGetItemArgs); if ((int)result != 0) { throw new Exception("Error occured while retrieving vault item. Error: 0x" + result.ToString()); } object passwordItem = System.Runtime.InteropServices.Marshal.PtrToStructure(passwordVaultItem, VAULT_ITEM); FieldInfo pAuthenticatorElementInfo = passwordItem.GetType().GetField("pAuthenticatorElement"); IntPtr pAuthenticatorElement = (IntPtr)pAuthenticatorElementInfo.GetValue(passwordItem); // Fetch the credential from the authenticator element object cred = GetVaultElementValue(pAuthenticatorElement); object packageSid = null; if (vaultGetItemArgs.Length == 8 && (IntPtr)vaultGetItemArgs[4] != IntPtr.Zero) { packageSid = GetVaultElementValue((IntPtr)vaultGetItemArgs[4]); } if (cred != null) // Indicates successful fetch { Console.WriteLine("--- Result ---"); Console.WriteLine("Vault Type : {0}", vaultType); object resource = GetVaultElementValue(pResourceElement); if (resource != null) { Console.WriteLine("Resource : {0}", resource); } object identity = GetVaultElementValue(pIdentityElement); if (identity != null) { Console.WriteLine("Identity : {0}", identity); } if (packageSid != null) { Console.WriteLine("PacakgeSid : {0}", packageSid); } Console.WriteLine("Credential : {0}", cred); // Stupid datetime Console.WriteLine("LastModified : {0}", System.DateTime.FromFileTimeUtc((long)lastModified)); } } } } Console.WriteLine("[*] All vaults searched. Exiting."); }
public void SetCustomAttribute(CustomAttributeBuilder customBuilder) { m_type.SetGenParamCustomAttribute(customBuilder); }
public void SetCustomAttribute(CustomAttributeBuilder customBuilder) { _tb.SetCustomAttribute(customBuilder); }
private void SetCustomAttributeNoLock(CustomAttributeBuilder customBuilder) { customBuilder.CreateCustomAttribute(_manifestModuleBuilder, AssemblyBuilderData.AssemblyDefToken); }
internal static UnmanagedMarshal get_umarshal(CustomAttributeBuilder customBuilder, bool is_field) { byte[] data = customBuilder.Data; UnmanagedType subtype = (UnmanagedType)0x50; /* NATIVE_MAX */ int sizeConst = -1; int sizeParamIndex = -1; bool hasSize = false; int value; int utype; /* the (stupid) ctor takes a short or an enum ... */ string marshalTypeName = null; Type marshalTypeRef = null; string marshalCookie = String.Empty; utype = (int)data [2]; utype |= ((int)data [3]) << 8; string first_type_name = GetParameters(customBuilder.Ctor) [0].ParameterType.FullName; int pos = 6; if (first_type_name == "System.Int16") { pos = 4; } int nnamed = (int)data [pos++]; nnamed |= ((int)data [pos++]) << 8; for (int i = 0; i < nnamed; ++i) { int paramType; // What is this ? /* Skip field/property signature */ pos++; /* Read type */ paramType = ((int)data [pos++]); if (paramType == 0x55) { /* enums, the value is preceeded by the type */ int len2 = decode_len(data, pos, out pos); string_from_bytes(data, pos, len2); pos += len2; } int len = decode_len(data, pos, out pos); string named_name = string_from_bytes(data, pos, len); pos += len; switch (named_name) { case "ArraySubType": value = (int)data [pos++]; value |= ((int)data [pos++]) << 8; value |= ((int)data [pos++]) << 16; value |= ((int)data [pos++]) << 24; subtype = (UnmanagedType)value; break; case "SizeConst": value = (int)data [pos++]; value |= ((int)data [pos++]) << 8; value |= ((int)data [pos++]) << 16; value |= ((int)data [pos++]) << 24; sizeConst = value; hasSize = true; break; case "SafeArraySubType": value = (int)data[pos++]; value |= ((int)data[pos++]) << 8; value |= ((int)data[pos++]) << 16; value |= ((int)data[pos++]) << 24; subtype = (UnmanagedType)value; break; case "IidParameterIndex": pos += 4; break; case "SafeArrayUserDefinedSubType": len = decode_len(data, pos, out pos); string_from_bytes(data, pos, len); pos += len; break; case "SizeParamIndex": value = (int)data [pos++]; value |= ((int)data [pos++]) << 8; sizeParamIndex = value; hasSize = true; break; case "MarshalType": len = decode_len(data, pos, out pos); marshalTypeName = string_from_bytes(data, pos, len); pos += len; break; case "MarshalTypeRef": len = decode_len(data, pos, out pos); marshalTypeName = string_from_bytes(data, pos, len); marshalTypeRef = Type.GetType(marshalTypeName); pos += len; break; case "MarshalCookie": len = decode_len(data, pos, out pos); marshalCookie = string_from_bytes(data, pos, len); pos += len; break; default: throw new Exception("Unknown MarshalAsAttribute field: " + named_name); } } switch ((UnmanagedType)utype) { case UnmanagedType.LPArray: if (hasSize) { return(UnmanagedMarshal.DefineLPArrayInternal(subtype, sizeConst, sizeParamIndex)); } else { return(UnmanagedMarshal.DefineLPArray(subtype)); } case UnmanagedType.SafeArray: return(UnmanagedMarshal.DefineSafeArray(subtype)); case UnmanagedType.ByValArray: if (!is_field) { throw new ArgumentException("Specified unmanaged type is only valid on fields"); } return(UnmanagedMarshal.DefineByValArray(sizeConst)); case UnmanagedType.ByValTStr: return(UnmanagedMarshal.DefineByValTStr(sizeConst)); case UnmanagedType.CustomMarshaler: return(UnmanagedMarshal.DefineCustom(marshalTypeRef, marshalCookie, marshalTypeName, Guid.Empty)); default: return(UnmanagedMarshal.DefineUnmanagedMarshal((UnmanagedType)utype)); } }
internal static CustomAttributeInfo decode_cattr(CustomAttributeBuilder customBuilder) { byte[] data = customBuilder.Data; ConstructorInfo ctor = customBuilder.Ctor; int pos = 0; CustomAttributeInfo info = new CustomAttributeInfo(); // Prolog if (data.Length < 2) { throw new Exception("Custom attr length is only '" + data.Length + "'"); } if ((data [0] != 0x1) || (data [1] != 0x00)) { throw new Exception("Prolog invalid"); } pos = 2; ParameterInfo [] pi = GetParameters(ctor); info.ctor = ctor; info.ctorArgs = new object [pi.Length]; for (int i = 0; i < pi.Length; ++i) { info.ctorArgs [i] = decode_cattr_value(pi [i].ParameterType, data, pos, out pos); } int num_named = data [pos] + (data [pos + 1] * 256); pos += 2; info.namedParamNames = new string [num_named]; info.namedParamValues = new object [num_named]; for (int i = 0; i < num_named; ++i) { int named_type = data [pos++]; int data_type = data [pos++]; string enum_type_name = null; if (data_type == 0x55) { int len2 = decode_len(data, pos, out pos); enum_type_name = string_from_bytes(data, pos, len2); pos += len2; } int len = decode_len(data, pos, out pos); string name = string_from_bytes(data, pos, len); info.namedParamNames [i] = name; pos += len; if (named_type == 0x53) { /* Field */ FieldInfo fi = ctor.DeclaringType.GetField(name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); if (fi == null) { throw new Exception("Custom attribute type '" + ctor.DeclaringType + "' doesn't contain a field named '" + name + "'"); } object val = decode_cattr_value(fi.FieldType, data, pos, out pos); if (enum_type_name != null) { Type enumType = Type.GetType(enum_type_name); val = Enum.ToObject(enumType, val); } info.namedParamValues [i] = val; } else { // FIXME: throw new Exception("Unknown named type: " + named_type); } } return(info); }
public void SetCustomAttribute(CustomAttributeBuilder customBuilder) { m_methodBuilder.SetCustomAttribute(customBuilder); }
public void SetCustomAttribute(CustomAttributeBuilder customBuilder) { if (customBuilder == null) { throw new ArgumentNullException("customBuilder"); } switch (customBuilder.Ctor.ReflectedType.FullName) { case "System.Runtime.CompilerServices.MethodImplAttribute": byte[] data = customBuilder.Data; int impla; // the (stupid) ctor takes a short or an int ... impla = (int)data [2]; impla |= ((int)data [3]) << 8; iattrs |= (MethodImplAttributes)impla; return; case "System.Runtime.InteropServices.DllImportAttribute": CustomAttributeBuilder.CustomAttributeInfo attr = CustomAttributeBuilder.decode_cattr(customBuilder); bool preserveSig = true; /* * It would be easier to construct a DllImportAttribute from * the custom attribute builder, but the DllImportAttribute * does not contain all the information required here, ie. * - some parameters, like BestFitMapping has three values * ("on", "off", "missing"), but DllImportAttribute only * contains two (on/off). * - PreserveSig is true by default, while it is false by * default in DllImportAttribute. */ pi_dll = (string)attr.ctorArgs[0]; if (pi_dll == null || pi_dll.Length == 0) { throw new ArgumentException("DllName cannot be empty"); } native_cc = System.Runtime.InteropServices.CallingConvention.Winapi; for (int i = 0; i < attr.namedParamNames.Length; ++i) { string name = attr.namedParamNames [i]; object value = attr.namedParamValues [i]; if (name == "CallingConvention") { native_cc = (CallingConvention)value; } else if (name == "CharSet") { charset = (CharSet)value; } else if (name == "EntryPoint") { pi_entry = (string)value; } else if (name == "ExactSpelling") { ExactSpelling = (bool)value; } else if (name == "SetLastError") { SetLastError = (bool)value; } else if (name == "PreserveSig") { preserveSig = (bool)value; } else if (name == "BestFitMapping") { BestFitMapping = (bool)value; } else if (name == "ThrowOnUnmappableChar") { ThrowOnUnmappableChar = (bool)value; } } attrs |= MethodAttributes.PinvokeImpl; if (preserveSig) { iattrs |= MethodImplAttributes.PreserveSig; } return; case "System.Runtime.InteropServices.PreserveSigAttribute": iattrs |= MethodImplAttributes.PreserveSig; return; case "System.Runtime.CompilerServices.SpecialNameAttribute": attrs |= MethodAttributes.SpecialName; return; case "System.Security.SuppressUnmanagedCodeSecurityAttribute": attrs |= MethodAttributes.HasSecurity; break; } if (cattrs != null) { CustomAttributeBuilder[] new_array = new CustomAttributeBuilder [cattrs.Length + 1]; cattrs.CopyTo(new_array, 0); new_array [cattrs.Length] = customBuilder; cattrs = new_array; } else { cattrs = new CustomAttributeBuilder [1]; cattrs [0] = customBuilder; } }
public void SetCustomAttribute(CustomAttributeBuilder customBuilder) { throw new NotImplementedException(); }