public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, String name, PropertyAttributes attributes,
Type propertyType)
{
this.parentTypeEmitter = parentTypeEmitter;
// DYNPROXY-73 - AmbiguousMatchException for properties
// This is a workaround for a framework limitation in CLR 2.0
// This limitation was removed in CLR 2.0 SP1, but we don't want to
// tie ourselves to that version. This perform the lookup for the new overload
// dynamically, so we have a nice fallback on vanilla CLR 2.0
if (TypeBuilderMethods.DefineProperty == null)
{
DefineProperty_Clr2_0 oldDefineProperty = parentTypeEmitter.TypeBuilder.DefineProperty;
builder = oldDefineProperty(name, attributes, propertyType, new Type[0]);
}
else
{
DefineProperty_Clr_2_0_SP1 newDefinedProperty = (DefineProperty_Clr_2_0_SP1)
Delegate.CreateDelegate(typeof(DefineProperty_Clr_2_0_SP1),
parentTypeEmitter.TypeBuilder,
TypeBuilderMethods.DefineProperty);
builder = newDefinedProperty(
name, attributes, CallingConventions.HasThis, propertyType,
null, null, new Type[0], null, null);
}
}
// private ParameterInfo[] indexParameters;
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes,
Type propertyType, Type[] arguments)
{
this.parentTypeEmitter = parentTypeEmitter;
// DYNPROXY-73 - AmbiguousMatchException for properties
// This is a workaround for a framework limitation in CLR 2.0
// This limitation was removed in CLR 2.0 SP1, but we don't want to
// tie ourselves to that version. This perform the lookup for the new overload
// dynamically, so we have a nice fallback on vanilla CLR 2.0
if (TypeBuilderMethods.DefineProperty == null)
{
DefineProperty_Clr2_0 oldDefineProperty = parentTypeEmitter.TypeBuilder.DefineProperty;
builder = oldDefineProperty(name, attributes, propertyType, arguments);
}
else
{
var newDefinedProperty = (DefineProperty_Clr_2_0_SP1)
Delegate.CreateDelegate(typeof(DefineProperty_Clr_2_0_SP1),
parentTypeEmitter.TypeBuilder,
TypeBuilderMethods.DefineProperty);
builder = newDefinedProperty(
name, attributes, CallingConventions.HasThis, propertyType,
null, null, arguments, null, null);
}
}
public static Type GetClosedParameterType(this AbstractTypeEmitter type, Type parameter)
{
if (parameter.IsGenericTypeDefinition)
{
return(parameter.GetGenericTypeDefinition().MakeGenericType(type.GetGenericArgumentsFor(parameter)));
}
if (parameter.IsGenericType)
{
var arguments = parameter.GetGenericArguments();
if (CloseGenericParametersIfAny(type, arguments))
{
return(parameter.GetGenericTypeDefinition().MakeGenericType(arguments));
}
}
if (parameter.IsGenericParameter)
{
return(type.GetGenericArgument(parameter.Name));
}
if (parameter.IsArray)
{
var elementType = GetClosedParameterType(type, parameter.GetElementType());
return(elementType.MakeArrayType());
}
if (parameter.IsByRef)
{
var elementType = GetClosedParameterType(type, parameter.GetElementType());
return(elementType.MakeByRefType());
}
return(parameter);
}
public NestedClassEmitter(AbstractTypeEmitter maintype, String name, Type baseType, Type[] interfaces)
: this(
maintype,
CreateTypeBuilder(maintype, name, TypeAttributes.Sealed | TypeAttributes.NestedPublic | TypeAttributes.Class,
baseType, interfaces))
{
}
private static TypeBuilder CreateTypeBuilder(AbstractTypeEmitter maintype, string name, TypeAttributes attributes, Type baseType, Type[] interfaces)
{
return(maintype.TypeBuilder.DefineNestedType(
name,
attributes,
baseType, interfaces));
}
public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args,
Reference targetField,
MethodEmitter invokeMethodOnTarget)
{
var @delegate = GetDelegate(invocation, invokeMethodOnTarget);
return new MethodInvocationExpression(@delegate, GetCallbackMethod(), args);
}
internal MethodEmitter(
AbstractTypeEmitter owner,
string name,
MethodAttributes attributes,
MethodInfo methodToUseAsATemplate
) : this(owner, name, attributes)
{
// All code paths leading up to this constructor can be traced back to
// proxy type generation code. At present, proxy types are never generic.
Debug.Assert(owner.GenericTypeParams == null || owner.GenericTypeParams.Length == 0);
var returnType = methodToUseAsATemplate.ReturnType;
var baseMethodParameters = methodToUseAsATemplate.GetParameters();
var parameters = ArgumentsUtil.GetTypes(baseMethodParameters);
genericTypeParams = GenericUtil.CopyGenericArguments(methodToUseAsATemplate, builder);
SetParameters(parameters);
SetReturnType(returnType);
SetSignature(
returnType,
methodToUseAsATemplate.ReturnParameter,
parameters,
baseMethodParameters
);
DefineParameters(baseMethodParameters);
}
protected override void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocation, ParameterInfo[] parameters, MethodEmitter invokeMethodOnTarget, Reference targetField)
{
invokeMethodOnTarget.CodeBuilder.AddStatement(
new ExpressionStatement(
new MethodInvocationExpression(SelfReference.Self, InvocationMethods.EnsureValidTarget)));
base.ImplementInvokeMethodOnTarget(invocation, parameters, invokeMethodOnTarget, targetField);
}
// private ParameterInfo[] indexParameters;
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, String name, PropertyAttributes attributes,
Type propertyType)
{
this.parentTypeEmitter = parentTypeEmitter;
builder = parentTypeEmitter.TypeBuilder.DefineProperty(name, attributes, propertyType, new Type[0]);
}
public NestedClassEmitter(AbstractTypeEmitter maintype, String name, Type baseType, Type[] interfaces)
: this(
maintype,
CreateTypeBuilder(maintype, name, TypeAttributes.Sealed | TypeAttributes.NestedPublic | TypeAttributes.Class,
baseType, interfaces))
{
}
private static TypeBuilder CreateTypeBuilder(AbstractTypeEmitter maintype, string name, Type baseType, Type[] interfaces)
{
return maintype.TypeBuilder.DefineNestedType(
name,
TypeAttributes.Sealed | TypeAttributes.NestedPublic | TypeAttributes.Class,
baseType, interfaces);
}
private static TypeBuilder CreateTypeBuilder(AbstractTypeEmitter maintype, string name, TypeAttributes attributes, Type baseType, Type[] interfaces)
{
return maintype.TypeBuilder.DefineNestedType(
name,
attributes,
baseType, interfaces);
}
public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args, Reference targetField, MethodEmitter invokeMethodOnTarget)
{
var allArgs = GetAllArgs(args, targetField);
var @delegate = (Reference)invocation.GetField("delegate");
return new MethodInvocationExpression(@delegate, GetCallbackMethod(), allArgs);
}
public EventEmitter(AbstractTypeEmitter typeEmitter, string name, EventAttributes attributes, Type type)
{
this.typeEmitter = typeEmitter;
this.type = type;
this.name = name;
eventBuilder = typeEmitter.TypeBuilder.DefineEvent(name, attributes, type);
}
public static Type GetClosedParameterType(AbstractTypeEmitter type, Type parameter)
{
if (parameter.IsGenericTypeDefinition)
{
return parameter.GetGenericTypeDefinition().MakeGenericType(type.GetGenericArgumentsFor(parameter));
}
if (parameter.IsGenericType)
{
Type[] arguments = parameter.GetGenericArguments();
if (CloseGenericParametersIfAny(type, arguments))
{
return parameter.GetGenericTypeDefinition().MakeGenericType(arguments);
}
}
if (parameter.IsGenericParameter)
{
return type.GetGenericArgument(parameter.Name);
}
if (parameter.IsArray)
{
var elementType = GetClosedParameterType(type, parameter.GetElementType());
return elementType.MakeArrayType();
}
if(parameter.IsByRef)
{
var elementType = GetClosedParameterType(type, parameter.GetElementType());
return elementType.MakeByRefType();
}
return parameter;
}
public EventEmitter(AbstractTypeEmitter typeEmitter, string name, EventAttributes attributes, Type type)
{
if (name == null) throw new ArgumentNullException("name");
if (type == null) throw new ArgumentNullException("type");
this.typeEmitter = typeEmitter;
this.type = type;
eventBuilder = typeEmitter.TypeBuilder.DefineEvent(name, attributes, type);
}
internal MethodEmitter(AbstractTypeEmitter owner, String name,
MethodAttributes attributes, Type returnType,
params Type[] argumentTypes)
: this(owner, name, attributes)
{
SetParameters(argumentTypes);
SetReturnType(returnType);
}
internal ConstructorEmitter(AbstractTypeEmitter maintype, params ArgumentReference[] arguments)
{
this.maintype = maintype;
var args = ArgumentsUtil.InitializeAndConvert(arguments);
builder = maintype.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, args);
}
internal MethodEmitter(AbstractTypeEmitter owner, String name,
MethodAttributes attributes, Type returnType,
params Type[] argumentTypes)
: this(owner, name, attributes)
{
SetParameters(argumentTypes);
SetReturnType(returnType);
}
internal ConstructorEmitter(AbstractTypeEmitter maintype, params ArgumentReference[] arguments)
{
this.maintype = maintype;
var args = ArgumentsUtil.InitializeAndConvert(arguments);
builder = maintype.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, args);
}
protected internal ConstructorEmitter(
AbstractTypeEmitter maintype,
ConstructorBuilder builder
)
{
this.maintype = maintype;
this.builder = builder;
codeBuilder = new CodeBuilder();
}
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes,
Type propertyType, Type[] arguments)
{
this.parentTypeEmitter = parentTypeEmitter;
builder = parentTypeEmitter.TypeBuilder.DefineProperty(
name, attributes, CallingConventions.HasThis, propertyType,
null, null, arguments, null, null);
}
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes,
Type propertyType, Type[] arguments)
{
this.parentTypeEmitter = parentTypeEmitter;
builder = parentTypeEmitter.TypeBuilder.DefineProperty(
name, attributes, CallingConventions.HasThis, propertyType,
null, null, arguments, null, null);
}
public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation)
{
var arguments = GetArguments(baseCtorArguments);
var constructor = invocation.CreateConstructor(arguments);
var delegateField = invocation.CreateField("delegate", delegateType);
constructor.CodeBuilder.AddStatement(new AssignStatement(delegateField, new ReferenceExpression(arguments[0])));
return constructor;
}
public NestedClassEmitter(
AbstractTypeEmitter maintype,
string name,
TypeAttributes attributes,
Type baseType,
Type[] interfaces
) : this(maintype, CreateTypeBuilder(maintype, name, attributes, baseType, interfaces))
{
}
private Reference GetDelegate(AbstractTypeEmitter invocation, MethodEmitter invokeMethodOnTarget)
{
var closedDelegateType = delegateType.MakeGenericType(invocation.GenericTypeParams);
var localReference = invokeMethodOnTarget.CodeBuilder.DeclareLocal(closedDelegateType);
var closedMethodOnTarget = method.MethodOnTarget.MakeGenericMethod(invocation.GenericTypeParams);
var localTarget = new ReferenceExpression(targetReference);
invokeMethodOnTarget.CodeBuilder.AddStatement(
SetDelegate(localReference, localTarget, closedDelegateType, closedMethodOnTarget));
return localReference;
}
public static void PopulateGenericArguments(
AbstractTypeEmitter parentEmitter,
Dictionary<String, GenericTypeParameterBuilder> name2GenericType)
{
if (parentEmitter.GenericTypeParams == null) return;
foreach (GenericTypeParameterBuilder genType in parentEmitter.GenericTypeParams)
{
name2GenericType.Add(genType.Name, genType);
}
}
public static void PopulateGenericArguments(
AbstractTypeEmitter parentEmitter,
Dictionary <String, GenericTypeParameterBuilder> name2GenericType)
{
if (parentEmitter.GenericTypeParams == null)
{
return;
}
foreach (GenericTypeParameterBuilder genType in parentEmitter.GenericTypeParams)
{
name2GenericType.Add(genType.Name, genType);
}
}
public static Dictionary<string, GenericTypeParameterBuilder> GetGenericArgumentsMap(AbstractTypeEmitter parentEmitter)
{
if (parentEmitter.GenericTypeParams == null || parentEmitter.GenericTypeParams.Length == 0)
{
return new Dictionary<string, GenericTypeParameterBuilder>(0);
}
var name2GenericType = new Dictionary<string, GenericTypeParameterBuilder>(parentEmitter.GenericTypeParams.Length);
foreach (var genType in parentEmitter.GenericTypeParams)
{
name2GenericType.Add(genType.Name, genType);
}
return name2GenericType;
}
public EventEmitter(AbstractTypeEmitter typeEmitter, string name, EventAttributes attributes, Type type)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
this.typeEmitter = typeEmitter;
this.type = type;
eventBuilder = typeEmitter.TypeBuilder.DefineEvent(name, attributes, type);
}
private static bool CloseGenericParametersIfAny(AbstractTypeEmitter emitter, Type[] arguments)
{
var hasAnyGenericParameters = false;
for (var i = 0; i < arguments.Length; i++)
{
var newType = GetClosedParameterType(emitter, arguments[i]);
if (!ReferenceEquals(newType, arguments[i]))
{
arguments[i] = newType;
hasAnyGenericParameters = true;
}
}
return(hasAnyGenericParameters);
}
/// <summary>
/// Inspect the base method for generic definitions
/// and set the return type and the parameters
/// accordingly
/// </summary>
public void CopyParametersAndReturnTypeFrom(MethodInfo baseMethod, AbstractTypeEmitter parentEmitter)
{
GenericUtil.PopulateGenericArguments(parentEmitter, name2GenericType);
Type returnType = GenericUtil.ExtractCorrectType(baseMethod.ReturnType, name2GenericType);
ParameterInfo[] baseMethodParameters = baseMethod.GetParameters();
Type[] parameters = GenericUtil.ExtractParametersTypes
(baseMethodParameters, name2GenericType);
// Disabled due to .Net 3.5 SP 1 bug
// List<Type[]> paramModReq = new List<Type[]>();
// List<Type[]> paramModOpt = new List<Type[]>();
// foreach (ParameterInfo parameterInfo in baseMethodParameters)
// {
// paramModOpt.Add(parameterInfo.GetOptionalCustomModifiers());
// paramModReq.Add(parameterInfo.GetRequiredCustomModifiers());
// }
Type[] genericArguments = baseMethod.GetGenericArguments();
genericTypeParams = GenericUtil.DefineGenericArguments(genericArguments, builder, name2GenericType);
// Bind parameter types
SetParameters(GenericUtil.ExtractParametersTypes(baseMethodParameters, name2GenericType));
// TODO: check if the return type is a generic
// definition for the method
SetReturnType(GenericUtil.ExtractCorrectType(baseMethod.ReturnType, name2GenericType));
#if SILVERLIGHT
#warning What to do?
#else
builder.SetSignature(
returnType,
// Disabled due to .Net 3.5 SP 1 bug
//baseMethod.ReturnParameter.GetRequiredCustomModifiers(),
//baseMethod.ReturnParameter.GetOptionalCustomModifiers(),
Type.EmptyTypes,
Type.EmptyTypes,
parameters,
null, null
// paramModReq.ToArray(),
// paramModOpt.ToArray()
);
#endif
DefineParameters(baseMethodParameters);
}
internal MethodEmitter(AbstractTypeEmitter owner, String name,
MethodAttributes attributes, MethodInfo methodToUseAsATemplate)
: this(owner, name, attributes)
{
var name2GenericType = GenericUtil.GetGenericArgumentsMap(owner);
var returnType = GenericUtil.ExtractCorrectType(methodToUseAsATemplate.ReturnType, name2GenericType);
var baseMethodParameters = methodToUseAsATemplate.GetParameters();
var parameters = GenericUtil.ExtractParametersTypes(baseMethodParameters, name2GenericType);
genericTypeParams = GenericUtil.CopyGenericArguments(methodToUseAsATemplate, builder, name2GenericType);
SetParameters(parameters);
SetReturnType(returnType);
SetSignature(returnType, methodToUseAsATemplate.ReturnParameter, parameters, baseMethodParameters);
DefineParameters(baseMethodParameters);
}
internal MethodEmitter(AbstractTypeEmitter owner, String name,
MethodAttributes attributes, MethodInfo methodToUseAsATemplate)
: this(owner, name, attributes)
{
var name2GenericType = GenericUtil.GetGenericArgumentsMap(owner);
var returnType = GenericUtil.ExtractCorrectType(methodToUseAsATemplate.ReturnType, name2GenericType);
var baseMethodParameters = methodToUseAsATemplate.GetParameters();
var parameters = GenericUtil.ExtractParametersTypes(baseMethodParameters, name2GenericType);
genericTypeParams = GenericUtil.CopyGenericArguments(methodToUseAsATemplate, builder, name2GenericType);
SetParameters(parameters);
SetReturnType(returnType);
SetSignature(returnType, methodToUseAsATemplate.ReturnParameter, parameters, baseMethodParameters);
DefineParameters(baseMethodParameters);
}
/// <summary>
/// Inspect the base method for generic definitions
/// and set the return type and the parameters
/// accordingly
/// </summary>
public void CopyParametersAndReturnTypeFrom(MethodInfo baseMethod, AbstractTypeEmitter parentEmitter)
{
GenericUtil.PopulateGenericArguments(parentEmitter, name2GenericType);
var returnType = GenericUtil.ExtractCorrectType(baseMethod.ReturnType, name2GenericType);
var baseMethodParameters = baseMethod.GetParameters();
var parameters = GenericUtil.ExtractParametersTypes(baseMethodParameters, name2GenericType);
genericTypeParams = GenericUtil.CopyGenericArguments(baseMethod, builder, name2GenericType);
// Bind parameter types
// TODO: check if the return type is a generic
// definition for the method
SetParameters(parameters);
SetReturnType(returnType);
DefineParameters(baseMethodParameters);
}
/// <summary>
/// Inspect the base method for generic definitions
/// and set the return type and the parameters
/// accordingly
/// </summary>
public void CopyParametersAndReturnTypeFrom(MethodInfo baseMethod, AbstractTypeEmitter parentEmitter)
{
GenericUtil.PopulateGenericArguments(parentEmitter, name2GenericType);
Type returnType = GenericUtil.ExtractCorrectType(baseMethod.ReturnType, name2GenericType);
ParameterInfo[] baseMethodParameters = baseMethod.GetParameters();
Type[] parameters = GenericUtil.ExtractParametersTypes
(baseMethodParameters, name2GenericType);
//// Disabled for .NET due to .Net 3.5 SP 1 bug
//List<Type[]> paramModReq = new List<Type[]>();
//List<Type[]> paramModOpt = new List<Type[]>();
//foreach (ParameterInfo parameterInfo in baseMethodParameters)
//{
// paramModOpt.Add(parameterInfo.GetOptionalCustomModifiers());
// paramModReq.Add(parameterInfo.GetRequiredCustomModifiers());
//}
genericTypeParams = GenericUtil.CopyGenericArguments(baseMethod, builder, name2GenericType);
// Bind parameter types
SetParameters(GenericUtil.ExtractParametersTypes(baseMethodParameters, name2GenericType));
// TODO: check if the return type is a generic
// definition for the method
SetReturnType(GenericUtil.ExtractCorrectType(baseMethod.ReturnType, name2GenericType));
builder.SetSignature(
returnType,
// Disabled due to .Net 3.5 SP 1 bug and Silverlight does not have this API
//baseMethod.ReturnParameter.GetRequiredCustomModifiers(),
//baseMethod.ReturnParameter.GetOptionalCustomModifiers(),
Type.EmptyTypes,
Type.EmptyTypes,
parameters,
null, null
// paramModReq.ToArray(),
// paramModOpt.ToArray()
);
DefineParameters(baseMethodParameters);
}
/// <summary>
/// Inspect the base method for generic definitions
/// and set the return type and the parameters
/// accordingly
/// </summary>
public void CopyParametersAndReturnTypeFrom(MethodInfo baseMethod, AbstractTypeEmitter parentEmitter)
{
GenericUtil.PopulateGenericArguments(parentEmitter, name2GenericType);
Type returnType = GenericUtil.ExtractCorrectType(baseMethod.ReturnType, name2GenericType);
ParameterInfo[] baseMethodParameters = baseMethod.GetParameters();
Type[] parameters = GenericUtil.ExtractParametersTypes
(baseMethodParameters, name2GenericType);
//// Disabled for .NET due to .Net 3.5 SP 1 bug
//List<Type[]> paramModReq = new List<Type[]>();
//List<Type[]> paramModOpt = new List<Type[]>();
//foreach (ParameterInfo parameterInfo in baseMethodParameters)
//{
// paramModOpt.Add(parameterInfo.GetOptionalCustomModifiers());
// paramModReq.Add(parameterInfo.GetRequiredCustomModifiers());
//}
genericTypeParams = GenericUtil.CopyGenericArguments(baseMethod, builder, name2GenericType);
// Bind parameter types
SetParameters(GenericUtil.ExtractParametersTypes(baseMethodParameters, name2GenericType));
// TODO: check if the return type is a generic
// definition for the method
SetReturnType(GenericUtil.ExtractCorrectType(baseMethod.ReturnType, name2GenericType));
builder.SetSignature(
returnType,
// Disabled due to .Net 3.5 SP 1 bug and Silverlight does not have this API
//baseMethod.ReturnParameter.GetRequiredCustomModifiers(),
//baseMethod.ReturnParameter.GetOptionalCustomModifiers(),
Type.EmptyTypes,
Type.EmptyTypes,
parameters,
null, null
// paramModReq.ToArray(),
// paramModOpt.ToArray()
);
DefineParameters(baseMethodParameters);
}
/// <summary>
/// Inspect the base method for generic definitions
/// and set the return type and the parameters
/// accordingly
/// </summary>
public void CopyParametersAndReturnTypeFrom(MethodInfo baseMethod, AbstractTypeEmitter parentEmitter)
{
GenericUtil.PopulateGenericArguments(parentEmitter, name2GenericType);
Type returnType = GenericUtil.ExtractCorrectType(baseMethod.ReturnType, name2GenericType);
ParameterInfo[] baseMethodParameters = baseMethod.GetParameters();
Type[] parameters = GenericUtil.ExtractParametersTypes
(baseMethodParameters, name2GenericType);
List<Type[]> paramModReq = new List<Type[]>();
List<Type[]> paramModOpt = new List<Type[]>();
foreach (ParameterInfo parameterInfo in baseMethodParameters)
{
paramModOpt.Add(parameterInfo.GetOptionalCustomModifiers());
paramModReq.Add(parameterInfo.GetRequiredCustomModifiers());
}
Type[] genericArguments = baseMethod.GetGenericArguments();
genericTypeParams = GenericUtil.DefineGenericArguments(genericArguments, builder, name2GenericType);
// Bind parameter types
SetParameters(GenericUtil.ExtractParametersTypes(baseMethodParameters, name2GenericType));
// TODO: check if the return type is a generic
// definition for the method
SetReturnType(GenericUtil.ExtractCorrectType(baseMethod.ReturnType, name2GenericType));
builder.SetSignature(
returnType,
baseMethod.ReturnParameter.GetRequiredCustomModifiers(),
baseMethod.ReturnParameter.GetOptionalCustomModifiers(),
parameters,
paramModReq.ToArray(),
paramModOpt.ToArray());
DefineParameters(baseMethodParameters);
}
// private ParameterInfo[] indexParameters;
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes,
Type propertyType, Type[] arguments)
{
this.parentTypeEmitter = parentTypeEmitter;
// DYNPROXY-73 - AmbiguousMatchException for properties
// This is a workaround for a framework limitation in CLR 2.0
// This limitation was removed in CLR 2.0 SP1, but we don't want to
// tie ourselves to that version. This perform the lookup for the new overload
// dynamically, so we have a nice fallback on vanilla CLR 2.0
// @mbrit - 2012-05-30 - it appears in WinRT, the old version works OK... new version is baffling...
#if !NETFX_CORE
bool isWinRt = false;
#else
bool isWinRt = true;
#endif
if (TypeBuilderMethods.DefineProperty == null || isWinRt)
{
DefineProperty_Clr2_0 oldDefineProperty = parentTypeEmitter.TypeBuilder.DefineProperty;
builder = oldDefineProperty(name, attributes, propertyType, arguments);
}
else
{
#if !NETFX_CORE
var newDefinedProperty = (DefineProperty_Clr_2_0_SP1)
Delegate.CreateDelegate(typeof(DefineProperty_Clr_2_0_SP1),
parentTypeEmitter.TypeBuilder,
TypeBuilderMethods.DefineProperty);
builder = newDefinedProperty(
name, attributes, CallingConventions.HasThis, propertyType,
null, null, arguments, null, null);
#endif
}
}
// private ParameterInfo[] indexParameters;
public PropertyEmitter(AbstractTypeEmitter parentTypeEmitter, string name, PropertyAttributes attributes,
Type propertyType, Type[] arguments)
{
this.parentTypeEmitter = parentTypeEmitter;
// DYNPROXY-73 - AmbiguousMatchException for properties
// This is a workaround for a framework limitation in CLR 2.0
// This limitation was removed in CLR 2.0 SP1, but we don't want to
// tie ourselves to that version. This perform the lookup for the new overload
// dynamically, so we have a nice fallback on vanilla CLR 2.0
// @mbrit - 2012-05-30 - it appears in WinRT, the old version works OK... new version is baffling...
#if !NETFX_CORE
bool isWinRt = false;
#else
bool isWinRt = true;
#endif
if (TypeBuilderMethods.DefineProperty == null || isWinRt)
{
DefineProperty_Clr2_0 oldDefineProperty = parentTypeEmitter.TypeBuilder.DefineProperty;
builder = oldDefineProperty(name, attributes, propertyType, arguments);
}
else
{
#if !NETFX_CORE
var newDefinedProperty = (DefineProperty_Clr_2_0_SP1)
Delegate.CreateDelegate(typeof(DefineProperty_Clr_2_0_SP1),
parentTypeEmitter.TypeBuilder,
TypeBuilderMethods.DefineProperty);
builder = newDefinedProperty(
name, attributes, CallingConventions.HasThis, propertyType,
null, null, arguments, null, null);
#endif
}
}
internal MethodEmitter(AbstractTypeEmitter owner, String name, MethodAttributes attributes)
: this(owner.TypeBuilder.DefineMethod(name, attributes))
{
}
private static bool CloseGenericParametersIfAny(AbstractTypeEmitter emitter, Type[] arguments)
{
var hasAnyGenericParameters = false;
for (var i = 0; i < arguments.Length; i++)
{
var newType = GetClosedParameterType(emitter, arguments[i]);
if (!ReferenceEquals(newType, arguments[i]))
{
arguments[i] = newType;
hasAnyGenericParameters = true;
}
}
return hasAnyGenericParameters;
}
internal TypeConstructorEmitter(AbstractTypeEmitter maintype)
: base(maintype, maintype.TypeBuilder.DefineTypeInitializer())
{
}
public static Dictionary <string, GenericTypeParameterBuilder> GetGenericArgumentsMap(AbstractTypeEmitter parentEmitter)
{
if (parentEmitter.GenericTypeParams == null || parentEmitter.GenericTypeParams.Length == 0)
{
return(new Dictionary <string, GenericTypeParameterBuilder>(0));
}
var name2GenericType = new Dictionary <string, GenericTypeParameterBuilder>(parentEmitter.GenericTypeParams.Length);
foreach (var genType in parentEmitter.GenericTypeParams)
{
name2GenericType.Add(genType.Name, genType);
}
return(name2GenericType);
}
internal MethodEmitter(AbstractTypeEmitter owner, String name, MethodAttributes attributes)
: this(owner.TypeBuilder.DefineMethod(name, attributes))
{
}
internal MethodEmitter(AbstractTypeEmitter maintype, String name, MethodAttributes attrs)
: this(maintype.TypeBuilder.DefineMethod(name, attrs))
{
}
internal TypeConstructorEmitter(AbstractTypeEmitter mainType)
: base(mainType, mainType.TypeBuilder.DefineTypeInitializer())
{
}
public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation)
{
return invocation.CreateConstructor(baseCtorArguments);
}
public NestedClassEmitter(AbstractTypeEmitter maintype, TypeBuilder typeBuilder)
: base(typeBuilder)
{
maintype.Nested.Add(this);
}
public NestedClassEmitter(AbstractTypeEmitter maintype, TypeBuilder typeBuilder)
: base(typeBuilder)
{
maintype.Nested.Add(this);
}
internal MethodEmitter(AbstractTypeEmitter maintype, String name, MethodAttributes attrs)
: this (maintype.TypeBuilder.DefineMethod(name, attrs))
{
this.maintype = maintype;
}