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 NestedClassEmitter(AbstractTypeEmitter maintype, String name, Type baseType, Type[] interfaces) : this( maintype, CreateTypeBuilder(maintype, name, TypeAttributes.Sealed | TypeAttributes.NestedPublic | TypeAttributes.Class, baseType, interfaces)) { }
// 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 || true) // TODO { 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); } }
protected override void ImplementInvokeMethodOnTarget(AbstractTypeEmitter @class, ParameterInfo[] parameters, MethodEmitter invokeMethodOnTarget, MethodInfo callbackMethod, Reference targetField) { invokeMethodOnTarget.CodeBuilder.AddStatement( new ExpressionStatement( new MethodInvocationExpression(SelfReference.Self, InvocationMethods.EnsureValidTarget))); base.ImplementInvokeMethodOnTarget(@class, parameters, invokeMethodOnTarget, callbackMethod, targetField); }
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 MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args, Reference targetField, MethodEmitter invokeMethodOnTarget) { var @delegate = GetDelegate(invocation, invokeMethodOnTarget); return new MethodInvocationExpression(@delegate, GetCallbackMethod(), args); }
public ConstructorEmitter CreateConstructor( ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation ) { return(invocation.CreateConstructor(baseCtorArguments)); }
protected override void ImplementInvokeMethodOnTarget(AbstractTypeEmitter invocation, MethodInfo method, MethodEmitter invokeMethodOnTarget, Reference targetField) { invokeMethodOnTarget.CodeBuilder.AddStatement( new ExpressionStatement( new MethodInvocationExpression(SelfReference.Self, InvocationMethods.EnsureValidTarget))); base.ImplementInvokeMethodOnTarget(invocation, method, invokeMethodOnTarget, targetField); }
private static TypeBuilder CreateTypeBuilder(AbstractTypeEmitter maintype, string name, TypeAttributes attributes, Type baseType, Type[] interfaces) { return maintype.TypeBuilder.DefineNestedType( name, attributes, baseType, interfaces); }
internal MethodEmitter(AbstractTypeEmitter owner, String name, MethodAttributes attributes, Type returnType, params Type[] argumentTypes) : this(owner, name, attributes) { SetParameters(argumentTypes); SetReturnType(returnType); }
public MethodInvocationExpression GetCallbackMethodInvocation(AbstractTypeEmitter invocation, Expression[] args, Reference targetField, MethodEmitter invokeMethodOnTarget) { var @delegate = GetDelegate(invocation, invokeMethodOnTarget); return(new MethodInvocationExpression(@delegate, GetCallbackMethod(), args)); }
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 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); }
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; }
private Reference GetDelegate(AbstractTypeEmitter invocation, MethodEmitter invokeMethodOnTarget) { var closedDelegateType = delegateType.MakeGenericType(invocation.GenericTypeParams.AsTypes().ToArray()); var localReference = invokeMethodOnTarget.CodeBuilder.DeclareLocal(closedDelegateType); var closedMethodOnTarget = method.MethodOnTarget.MakeGenericMethod(invocation.GenericTypeParams.AsTypes().ToArray()); var localTarget = new ReferenceExpression(targetReference); invokeMethodOnTarget.CodeBuilder.AddStatement( SetDelegate(localReference, localTarget, closedDelegateType, closedMethodOnTarget)); return(localReference); }
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, arguments[0])); return(constructor); }
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 (newType != null && !ReferenceEquals(newType, arguments[i])) { arguments[i] = newType; hasAnyGenericParameters = true; } } return(hasAnyGenericParameters); }
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 ConstructorEmitter(AbstractTypeEmitter maintype, params ArgumentReference[] arguments) { this.maintype = maintype; var args = ArgumentsUtil.InitializeAndConvert(arguments); builder = maintype.TypeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, args); // if we don't copy the parameter attributes, the default binder will fail // when trying to resolve constructors from the passed argument values. for (int i = 0; i < args.Length; ++i) { var arg = arguments[i]; var paramBuilder = builder.DefineParameter(i + 1, arg.ParameterAttributes, ""); if (arg.DefaultValue != DBNull.Value) paramBuilder.SetConstant(arg.DefaultValue); } }
internal TypeConstructorEmitter(AbstractTypeEmitter maintype) : base(maintype, maintype.TypeBuilder.DefineTypeInitializer()) { }
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 (newType != null && !ReferenceEquals(newType, arguments[i])) { arguments[i] = newType; hasAnyGenericParameters = true; } } return hasAnyGenericParameters; }
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 NestedClassEmitter(AbstractTypeEmitter maintype, TypeBuilder typeBuilder) : base(typeBuilder) { maintype.Nested.Add(this); }
public CustomClassEmitter(AbstractTypeEmitter innerEmitter) { ArgumentUtility.CheckNotNull("innerEmitter", innerEmitter); _innerEmitter = innerEmitter; }
protected internal ConstructorEmitter(AbstractTypeEmitter maintype, ConstructorBuilder builder) { this.maintype = maintype; this.builder = builder; }
public ConstructorEmitter CreateConstructor(ArgumentReference[] baseCtorArguments, AbstractTypeEmitter invocation) { return invocation.CreateConstructor(baseCtorArguments); }