/// <inheritdoc />
public override TypeInfo Generate()
{
var argType = _invokeDelegateField.FieldType;
var proxyCtor = DynamicTypeBuilder.DefineConstructor(
MethodAttributes.Public, CallingConventions.HasThis, new [] { argType });
var badeType = DynamicTypeBuilder.BaseType.GetTypeInfo();
var baseCtor = badeType.DeclaredConstructors.Single(c => c.IsPublic && c.GetParameters().Length == 0);
var ilGenerator = proxyCtor.GetILGenerator();
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Call, baseCtor);
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldarg_1);
ilGenerator.Emit(OpCodes.Stfld, _invokeDelegateField);
ilGenerator.Emit(OpCodes.Ret);
return(DynamicTypeBuilder.CreateTypeInfo());
}
/// <inheritdoc />
public override TypeInfo Generate()
{
// Create backing field as:
// private string assemblyName;
var assemblyNameField =
DynamicTypeBuilder.DefineField("assemblyName", typeof(string), FieldAttributes.Private);
// Create ctor as:
// public IgnoresAccessChecksToAttribute(string)
var constructorBuilder = DynamicTypeBuilder.DefineConstructor(MethodAttributes.Public,
CallingConventions.HasThis,
new[] { assemblyNameField.FieldType });
var 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; } }
// ReSharper disable once UnusedVariable
var getterPropertyBuilder = DynamicTypeBuilder.DefineProperty(
"AssemblyName",
PropertyAttributes.None,
CallingConventions.HasThis,
returnType: typeof(string),
parameterTypes: null);
var getterMethodBuilder = DynamicTypeBuilder.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)]
var attributeUsageTypeInfo = typeof(AttributeUsageAttribute).GetTypeInfo();
// Find the ctor that takes only AttributeTargets
var attributeUsageConstructorInfo =
attributeUsageTypeInfo.DeclaredConstructors
.Single(c => c.GetParameters().Length == 1 &&
c.GetParameters()[0].ParameterType == typeof(AttributeTargets));
// Find the property to set AllowMultiple
var allowMultipleProperty =
attributeUsageTypeInfo.DeclaredProperties
.Single(f => string.Equals(f.Name, "AllowMultiple"));
// Create a builder to construct the instance via the ctor and property
var customAttributeBuilder =
new CustomAttributeBuilder(attributeUsageConstructorInfo,
new object[] { AttributeTargets.Assembly },
new[] { allowMultipleProperty },
new object[] { true });
// Attach this attribute instance to the newly defined attribute type
DynamicTypeBuilder.SetCustomAttribute(customAttributeBuilder);
// Make the TypeInfo real so the constructor can be used.
return(DynamicTypeBuilder.CreateTypeInfo());
}
