public DefineEvent ( string name, System attributes, System eventtype ) : System.Reflection.Emit.EventBuilder | ||
name | string | |
attributes | System | |
eventtype | System | |
Résultat | System.Reflection.Emit.EventBuilder |
public static void Generate( TypeBuilder typeBuilder, EventMetadata eventMetadata, MethodBuilder addMethod, MethodBuilder removeMethod, MethodBuilder raiseMethod) { var @event = typeBuilder.DefineEvent( eventMetadata.Name, eventMetadata.EventAttributes, eventMetadata.EventHandlerType); if (addMethod != null) { @event.SetAddOnMethod(addMethod); } if (removeMethod != null) { @event.SetRemoveOnMethod(removeMethod); } if (raiseMethod != null) { @event.SetRaiseMethod(raiseMethod); } }
private EventBuilder CreateProxyEventBuilder(TypeBuilder typeBuilder, EventInfo contractEvent) { var builder = typeBuilder.DefineEvent(contractEvent.Name, contractEvent.Attributes, contractEvent.EventHandlerType); return builder; }
protected void SetUp () { AssemblyName assemblyName = new AssemblyName(); assemblyName.Name = GetType().FullName; AssemblyBuilder assembly = Thread.GetDomain().DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess.Run); module = assembly.DefineDynamicModule("module1"); tb = module.DefineType("class1", TypeAttributes.Public); eb = tb.DefineEvent ("event1", EventAttributes.None, typeof (AnEvent)); mb = tb.DefineMethod ("OnAnEvent", MethodAttributes.Public, typeof (void), new Type [] { typeof (AnEvent) }); ILGenerator ilgen = mb.GetILGenerator(); ilgen.Emit (OpCodes.Ret); // These two are required eb.SetAddOnMethod (mb); eb.SetRemoveOnMethod (mb); }
public static void DefineEvent(TypeBuilder typeBuilder, EventInfo eventInfo, MethodBuilder addMethodBuilder, MethodBuilder removeMethodBuilder) { String eventName = eventInfo.DeclaringType.FullName + "." + eventInfo.Name; EventBuilder eventBuilder = typeBuilder.DefineEvent(eventName, EventAttributes.None, eventInfo.EventHandlerType); eventBuilder.SetAddOnMethod(addMethodBuilder); eventBuilder.SetRemoveOnMethod(removeMethodBuilder); }
private EventBuilder ImplementEvent(TypeBuilder typeBuilder, EventInfo eventToImplement, Type targetInterface) { var eventBuilder = typeBuilder.DefineEvent(eventToImplement.Name, EventAttributes.None, eventToImplement.EventHandlerType); var addMethodInfo = eventToImplement.GetAddMethod(); var removeMethodInfo = eventToImplement.GetRemoveMethod(); var addMethodBuilder = ImplementMethod(typeBuilder, addMethodInfo, targetInterface); var removeMethodBuilder = ImplementMethod(typeBuilder, removeMethodInfo, targetInterface); eventBuilder.SetAddOnMethod(addMethodBuilder); eventBuilder.SetRemoveOnMethod(removeMethodBuilder); return eventBuilder; }
public void Build(TypeBuilder builder, Type contractType) { builder.AddInterfaceImplementation(typeof(IAutoNotifyPropertyChanged)); FieldBuilder addPropertyChangedField = builder.DefineField("PropertyChanged", typeof (PropertyChangingEventHandler), FieldAttributes.Private); MethodBuilder addMethod = DefineAddOnMethod(builder, addPropertyChangedField); MethodBuilder removeMethod = DefineRemoveOnMethod(builder, addPropertyChangedField); MethodBuilder notifyPropertyChangedMethod = DefineRaiseMethod(builder, addPropertyChangedField); EventBuilder pcevent = builder.DefineEvent("PropertyChanged", EventAttributes.None, typeof(PropertyChangedEventHandler)); pcevent.SetRaiseMethod(notifyPropertyChangedMethod); pcevent.SetAddOnMethod(addMethod); pcevent.SetRemoveOnMethod(removeMethod); }
public static void Define(TypeBuilder typeB, Interface iface) { foreach (Method declMethod in iface.Methods) DefineMethod (typeB, declMethod.Name, ifaceMethAttr, declMethod.Arguments, false); if (iface.Properties != null) foreach (NDesk.DBus.Introspection.Property prop in iface.Properties) { Type propType = new Signature (prop.Type).ToType (); PropertyBuilder prop_builder = typeB.DefineProperty (prop.Name, PropertyAttributes.None, propType, Type.EmptyTypes); if (prop.Access == propertyAccess.read || prop.Access == propertyAccess.readwrite) prop_builder.SetGetMethod (typeB.DefineMethod ("get_" + prop.Name, ifaceMethAttr | MethodAttributes.SpecialName, propType, Type.EmptyTypes)); if (prop.Access == propertyAccess.write || prop.Access == propertyAccess.readwrite) prop_builder.SetSetMethod (typeB.DefineMethod ("set_" + prop.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] {propType})); } if (iface.Signals != null) foreach (NDesk.DBus.Introspection.Signal signal in iface.Signals) { Type eventType = DefineHandler (modBdef, signal); EventBuilder event_builder = typeB.DefineEvent (signal.Name, EventAttributes.None, eventType); event_builder.SetAddOnMethod (typeB.DefineMethod ("add_" + signal.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] {eventType})); event_builder.SetRemoveOnMethod (typeB.DefineMethod ("remove_" + signal.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] {eventType})); } //apply InterfaceAttribute ConstructorInfo interfaceAttributeCtor = typeof (InterfaceAttribute).GetConstructor(new Type[] {typeof (string)}); CustomAttributeBuilder cab = new CustomAttributeBuilder (interfaceAttributeCtor, new object[] {iface.Name}); typeB.SetCustomAttribute (cab); }
public MyEventBuilder (Event ev, TypeBuilder type_builder, string name, EventAttributes event_attr, Type event_type) { MyBuilder = type_builder.DefineEvent (name, event_attr, event_type); // And now store the values in our own fields. declaring_type = type_builder; reflected_type = type_builder; attributes = event_attr; this.name = name; my_event = ev; this.event_type = event_type; }
private static void MakeEvent(ModuleBuilder builder, EventInfo info, TypeBuilder typeBuilder, Type contextType, bool defaultImp) { var tName = info.Name; var tAddMethod = info.GetAddMethod(); var tRemoveMethod = info.GetRemoveMethod(); var tReturnType = info.EventHandlerType; var tCallSiteInvokeName = string.Format("Impromptu_Callsite_{1}_{0}", Guid.NewGuid().ToString("N"), tName); var tCStp = DefineBuilderForCallSite(builder, tCallSiteInvokeName); var tInvokeIsEvent = "Invoke_IsEvent"; var tInvokeIseventFuncType = tCStp.DefineCallsiteField(tInvokeIsEvent, typeof (bool)); var tInvokeAddAssign = "Invoke_AddAssign"; var tInvokeAddAssignFuncType = tCStp.DefineCallsiteField(tInvokeAddAssign, typeof (object), tReturnType); var tInvokeSubtractAssign = "Invoke_SubtractAssign"; var tInvokeSubtractAssignFuncType = tCStp.DefineCallsiteField(tInvokeSubtractAssign, typeof (object), tReturnType); var tAddParamTypes = tRemoveMethod.GetParameters().Select(it => it.ParameterType).ToArray(); var tInvokeAdd = "Invoke_Add"; var tInvokeAddFuncType = tCStp.DefineCallsiteField(tInvokeAdd, typeof (object), tAddParamTypes); var tRemoveParamTypes = tRemoveMethod.GetParameters().Select(it => it.ParameterType).ToArray(); var tInvokeRemove = "Invoke_Remove"; var tInvokeRemoveFuncType = tCStp.DefineCallsiteField(tInvokeRemove, typeof (object), tRemoveParamTypes); var tInvokeGet = "Invoke_Get"; var tInvokeGetFuncType = tCStp.DefineCallsiteField(tInvokeGet, typeof (object)); var tInvokeSet = "Invoke_Set"; var tInvokeSetFuncType = tCStp.DefineCallsiteField(tInvokeSet, typeof (object), typeof (object)); var tCallSite = tCStp.CreateType(); var tMp = typeBuilder.DefineEvent(tName, EventAttributes.None, tReturnType); //AddMethod var tPublicPrivate = MethodAttributes.Public; var tAddPrefixName = tAddMethod.Name; if (!defaultImp) { tAddPrefixName = String.Format("{0}.{1}", info.DeclaringType.FullName, tAddPrefixName); tPublicPrivate = MethodAttributes.Private; } var tAddBuilder = typeBuilder.DefineMethod(tAddPrefixName, tPublicPrivate | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.NewSlot, typeof (void), tAddParamTypes); if (!defaultImp) { typeBuilder.DefineMethodOverride(tAddBuilder, info.GetAddMethod()); } foreach (var tParam in tAddMethod.GetParameters()) { tAddBuilder.DefineParameter(tParam.Position + 1, AttributesForParam(tParam), tParam.Name); } var tIlGen = tAddBuilder.GetILGenerator(); var tIsEventField = tCallSite.GetFieldEvenIfGeneric(tInvokeIsEvent); using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tIsEventField))) { tIlGen.EmitDynamicIsEventBinder(CSharpBinderFlags.None, tName, contextType); tIlGen.EmitCallsiteCreate(tInvokeIseventFuncType); tIlGen.Emit(OpCodes.Stsfld, tIsEventField); } var tSetField = tCallSite.GetFieldEvenIfGeneric(tInvokeSet); var tGetField = tCallSite.GetFieldEvenIfGeneric(tInvokeGet); using (tIlGen.EmitBranchTrue( load => load.EmitInvocation( target => target.EmitInvocation( t => t.Emit(OpCodes.Ldsfld, tIsEventField), i => i.Emit(OpCodes.Ldfld, tIsEventField.FieldType.GetFieldEvenIfGeneric("Target")) ), invoke => invoke.EmitCallInvokeFunc(tInvokeIseventFuncType), param => param.Emit(OpCodes.Ldsfld, tIsEventField), param => param.EmitInvocation( t => t.Emit(OpCodes.Ldarg_0), i => i.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod()) ) ) ) ) //if IsEvent Not True { using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tSetField))) { tIlGen.EmitDynamicSetBinderDynamicParams(CSharpBinderFlags.ValueFromCompoundAssignment, tName, contextType, typeof (Object)); tIlGen.EmitCallsiteCreate(tInvokeSetFuncType); tIlGen.Emit(OpCodes.Stsfld, tSetField); } var tAddAssigneField = tCallSite.GetFieldEvenIfGeneric(tInvokeAddAssign); using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tAddAssigneField))) { tIlGen.EmitDynamicBinaryOpBinder(CSharpBinderFlags.None, ExpressionType.AddAssign, contextType, tReturnType); tIlGen.EmitCallsiteCreate(tInvokeAddAssignFuncType); tIlGen.Emit(OpCodes.Stsfld, tAddAssigneField); } using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tGetField))) { tIlGen.EmitDynamicGetBinder(CSharpBinderFlags.None, tName, contextType); tIlGen.EmitCallsiteCreate(tInvokeGetFuncType); tIlGen.Emit(OpCodes.Stsfld, tGetField); } tIlGen.Emit(OpCodes.Ldsfld, tSetField); tIlGen.Emit(OpCodes.Ldfld, tSetField.FieldType.GetFieldEvenIfGeneric("Target")); tIlGen.Emit(OpCodes.Ldsfld, tSetField); tIlGen.Emit(OpCodes.Ldarg_0); tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod()); tIlGen.Emit(OpCodes.Ldsfld, tAddAssigneField); tIlGen.Emit(OpCodes.Ldfld, tAddAssigneField.FieldType.GetFieldEvenIfGeneric("Target")); tIlGen.Emit(OpCodes.Ldsfld, tAddAssigneField); tIlGen.Emit(OpCodes.Ldsfld, tGetField); tIlGen.Emit(OpCodes.Ldfld, tGetField.FieldType.GetFieldEvenIfGeneric("Target")); tIlGen.Emit(OpCodes.Ldsfld, tGetField); tIlGen.Emit(OpCodes.Ldarg_0); tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod()); tIlGen.EmitCallInvokeFunc(tInvokeGetFuncType); tIlGen.Emit(OpCodes.Ldarg_1); tIlGen.EmitCallInvokeFunc(tInvokeAddAssignFuncType); tIlGen.EmitCallInvokeFunc(tInvokeSetFuncType); tIlGen.Emit(OpCodes.Pop); tIlGen.Emit(OpCodes.Ret); } var tAddCallSiteField = tCallSite.GetFieldEvenIfGeneric(tInvokeAdd); using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tAddCallSiteField))) { tIlGen.EmitDynamicMethodInvokeBinder( CSharpBinderFlags.InvokeSpecialName | CSharpBinderFlags.ResultDiscarded, tAddMethod.Name, contextType, tAddMethod.GetParameters(), Enumerable.Repeat(default(string), tAddParamTypes.Length)); tIlGen.EmitCallsiteCreate(tInvokeAddFuncType); tIlGen.Emit(OpCodes.Stsfld, tAddCallSiteField); } tIlGen.Emit(OpCodes.Ldsfld, tAddCallSiteField); tIlGen.Emit(OpCodes.Ldfld, tAddCallSiteField.FieldType.GetFieldEvenIfGeneric("Target")); tIlGen.Emit(OpCodes.Ldsfld, tAddCallSiteField); tIlGen.Emit(OpCodes.Ldarg_0); tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod()); for (var i = 1; i <= tAddParamTypes.Length; i++) { tIlGen.EmitLoadArgument(i); } tIlGen.EmitCallInvokeFunc(tInvokeAddFuncType); tIlGen.Emit(OpCodes.Pop); tIlGen.Emit(OpCodes.Ret); tMp.SetAddOnMethod(tAddBuilder); var tRemovePrefixName = tRemoveMethod.Name; if (!defaultImp) { tRemovePrefixName = String.Format("{0}.{1}", info.DeclaringType.FullName, tRemovePrefixName); } //Remove Method var tRemoveBuilder = typeBuilder.DefineMethod(tRemovePrefixName, tPublicPrivate | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.NewSlot, typeof (void), tAddParamTypes); if (!defaultImp) { typeBuilder.DefineMethodOverride(tRemoveBuilder, info.GetRemoveMethod()); } foreach (var tParam in tRemoveMethod.GetParameters()) { tRemoveBuilder.DefineParameter(tParam.Position + 1, AttributesForParam(tParam), tParam.Name); } tIlGen = tRemoveBuilder.GetILGenerator(); using (tIlGen.EmitBranchTrue(load => load.Emit(OpCodes.Ldsfld, tIsEventField))) { tIlGen.EmitDynamicIsEventBinder(CSharpBinderFlags.None, tName, contextType); tIlGen.EmitCallsiteCreate(tInvokeIseventFuncType); tIlGen.Emit(OpCodes.Stsfld, tIsEventField); } using (tIlGen.EmitBranchTrue( load => load.EmitInvocation( target => target.EmitInvocation( t => t.Emit(OpCodes.Ldsfld, tIsEventField), i => i.Emit(OpCodes.Ldfld, tIsEventField.FieldType.GetFieldEvenIfGeneric("Target")) ), invoke => invoke.EmitCallInvokeFunc(tInvokeIseventFuncType), param => param.Emit(OpCodes.Ldsfld, tIsEventField), param => param.EmitInvocation( t => t.Emit(OpCodes.Ldarg_0), i => i.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod()) ) ) ) ) //if IsEvent Not True { using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tSetField))) { tIlGen.EmitDynamicSetBinderDynamicParams(CSharpBinderFlags.ValueFromCompoundAssignment, tName, contextType, tReturnType); tIlGen.EmitCallsiteCreate(tInvokeSetFuncType); tIlGen.Emit(OpCodes.Stsfld, tSetField); } var tSubrtractAssignField = tCallSite.GetFieldEvenIfGeneric(tInvokeSubtractAssign); using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tSubrtractAssignField))) { tIlGen.EmitDynamicBinaryOpBinder(CSharpBinderFlags.None, ExpressionType.SubtractAssign, contextType, tReturnType); tIlGen.EmitCallsiteCreate(tInvokeSubtractAssignFuncType); tIlGen.Emit(OpCodes.Stsfld, tSubrtractAssignField); } using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tGetField))) { tIlGen.EmitDynamicGetBinder(CSharpBinderFlags.None, tName, contextType); tIlGen.EmitCallsiteCreate(tInvokeGetFuncType); tIlGen.Emit(OpCodes.Stsfld, tGetField); } tIlGen.Emit(OpCodes.Ldsfld, tSetField); tIlGen.Emit(OpCodes.Ldfld, tSetField.FieldType.GetFieldEvenIfGeneric("Target")); tIlGen.Emit(OpCodes.Ldsfld, tSetField); tIlGen.Emit(OpCodes.Ldarg_0); tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod()); tIlGen.Emit(OpCodes.Ldsfld, tSubrtractAssignField); tIlGen.Emit(OpCodes.Ldfld, tSubrtractAssignField.FieldType.GetFieldEvenIfGeneric("Target")); tIlGen.Emit(OpCodes.Ldsfld, tSubrtractAssignField); tIlGen.Emit(OpCodes.Ldsfld, tGetField); tIlGen.Emit(OpCodes.Ldfld, tGetField.FieldType.GetFieldEvenIfGeneric("Target")); tIlGen.Emit(OpCodes.Ldsfld, tGetField); tIlGen.Emit(OpCodes.Ldarg_0); tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod()); tIlGen.EmitCallInvokeFunc(tInvokeGetFuncType); tIlGen.Emit(OpCodes.Ldarg_1); tIlGen.EmitCallInvokeFunc(tInvokeSubtractAssignFuncType); tIlGen.EmitCallInvokeFunc(tInvokeSetFuncType); tIlGen.Emit(OpCodes.Pop); tIlGen.Emit(OpCodes.Ret); } var tRemoveCallSiteField = tCallSite.GetFieldEvenIfGeneric(tInvokeRemove); using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tRemoveCallSiteField))) { tIlGen.EmitDynamicMethodInvokeBinder( CSharpBinderFlags.InvokeSpecialName | CSharpBinderFlags.ResultDiscarded, tRemoveMethod.Name, contextType, tRemoveMethod.GetParameters(), Enumerable.Repeat(default(string), tRemoveParamTypes.Length)); tIlGen.EmitCallsiteCreate(tInvokeRemoveFuncType); tIlGen.Emit(OpCodes.Stsfld, tRemoveCallSiteField); } tIlGen.Emit(OpCodes.Ldsfld, tRemoveCallSiteField); tIlGen.Emit(OpCodes.Ldfld, tRemoveCallSiteField.FieldType.GetFieldEvenIfGeneric("Target")); tIlGen.Emit(OpCodes.Ldsfld, tRemoveCallSiteField); tIlGen.Emit(OpCodes.Ldarg_0); tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod()); tIlGen.Emit(OpCodes.Ldarg_1); tIlGen.EmitCallInvokeFunc(tInvokeRemoveFuncType); tIlGen.Emit(OpCodes.Pop); tIlGen.Emit(OpCodes.Ret); tMp.SetRemoveOnMethod(tRemoveBuilder); }
/// <summary> /// Compiles the type that is being built and returns its run-time Type. /// If you want to create instances directly, see the GetConstructorDelegate. /// </summary> public Type Compile() { if (_compiledType == null) { _CheckThread(); _delegates = new Delegate[_methods.Count]; var methodBuilders = new Dictionary <string, MethodBuilder>(); int index = -1; foreach (var method in _methods) { index++; var methodBuilder = _Compile(method, index); methodBuilders[method.Name] = methodBuilder; } foreach (var property in _properties.Values) { string name = property.Name; var propertyBuilder = _type.DefineProperty(name, PropertyAttributes.None, property.PropertyType, Type.EmptyTypes); propertyBuilder.SetGetMethod(methodBuilders["get_" + name]); propertyBuilder.SetSetMethod(methodBuilders["set_" + name]); } foreach (var eventInfo in _events.Values) { string name = eventInfo.Name; var eventBuilder = _type.DefineEvent(name, EventAttributes.None, eventInfo.Type); string addName = "add_" + name; string removeName = "remove_" + name; var addMethod = methodBuilders[addName]; var removeMethod = methodBuilders[removeName]; eventBuilder.SetAddOnMethod(addMethod); eventBuilder.SetRemoveOnMethod(removeMethod); foreach (var interfaceType in _interfaceTypes) { var method = interfaceType.GetMethod(addName); if (method != null) { _type.DefineMethodOverride(addMethod, method); } method = interfaceType.GetMethod(removeName); if (method != null) { _type.DefineMethodOverride(removeMethod, method); } } } var compiledType = _type.CreateType(); var thisExpression = Expression.Parameter(compiledType, "this"); var fields = _fields.ToArray(); foreach (var fieldPair in fields) { var leftPair = fieldPair.Key; var field = leftPair.Key; var rightPair = fieldPair.Value; string fieldName = rightPair.Value; var expression = Expression.MakeMemberAccess(thisExpression, compiledType.GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic)); _fields[leftPair] = new KeyValuePair <MemberExpression, string>(expression, fieldName); } index = -1; foreach (var method in _methods) { index++; if (method._respectVisibility) { continue; } if (!method.IsStatic) { var firstParameter = method._parameters.Keys.First(); method._parameters[firstParameter] = thisExpression; } var compiledMethod = method._Compile(null, null); _delegates[index] = compiledMethod; } var delegatesField = compiledType.GetField(".delegates", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); delegatesField.SetValue(null, _delegates); _compiledType = compiledType; } return(_compiledType); }
/************************************************************************/ /************************************************************************/ private static FieldBuilder CreatePropertyChangedEvent(TypeBuilder typeBuilder) { // public event PropertyChangedEventHandler PropertyChanged; FieldBuilder eventField = typeBuilder.DefineField("PropertyChanged", typeof(PropertyChangedEventHandler), FieldAttributes.Private); EventBuilder eventBuilder = typeBuilder.DefineEvent("PropertyChanged", EventAttributes.None, typeof(PropertyChangedEventHandler)); eventBuilder.SetAddOnMethod(CreateAddRemoveMethod(typeBuilder, eventField, true)); eventBuilder.SetRemoveOnMethod(CreateAddRemoveMethod(typeBuilder, eventField, false)); return eventField; }
public static void Define(TypeBuilder typeB, Interface iface) { foreach (Method declMethod in iface.Methods) { //MethodBuilder method_builder = typeB.DefineMethod (declMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual, declMethod.ReturnType, Mapper.GetTypes (ArgDirection.In, declMethod.GetParameters ())); List<Type> parms = new List<Type> (); if (declMethod.Arguments != null) foreach (Argument arg in declMethod.Arguments) { if (arg.Direction == Introspection.ArgDirection.@in) parms.Add (new Signature (arg.Type).ToType ()); //if (arg.Direction == Introspection.ArgDirection.@out) // parms.Add (new Signature (arg.Type).ToType ().MakeByRefType ()); } Signature outSig = Signature.Empty; //this just takes the last out arg and uses is as the return type if (declMethod.Arguments != null) foreach (Argument arg in declMethod.Arguments) if (arg.Direction == Introspection.ArgDirection.@out) outSig = new Signature (arg.Type); Type retType = outSig == Signature.Empty ? typeof (void) : outSig.ToType (); MethodBuilder method_builder = typeB.DefineMethod (declMethod.Name, ifaceMethAttr, retType, parms.ToArray ()); //define the parameter attributes and names if (declMethod.Arguments != null) { int argNum = 0; foreach (Argument arg in declMethod.Arguments) { if (arg.Direction == Introspection.ArgDirection.@in) method_builder.DefineParameter (++argNum, ParameterAttributes.In, arg.Name); //if (arg.Direction == Introspection.ArgDirection.@out) // method_builder.DefineParameter (++argNum, ParameterAttributes.Out, arg.Name); } } } if (iface.Properties != null) foreach (NDesk.DBus.Introspection.Property prop in iface.Properties) { Type propType = new Signature (prop.Type).ToType (); PropertyBuilder prop_builder = typeB.DefineProperty (prop.Name, PropertyAttributes.None, propType, Type.EmptyTypes); if (prop.Access == propertyAccess.read || prop.Access == propertyAccess.readwrite) prop_builder.SetGetMethod (typeB.DefineMethod ("get_" + prop.Name, ifaceMethAttr | MethodAttributes.SpecialName, propType, Type.EmptyTypes)); if (prop.Access == propertyAccess.write || prop.Access == propertyAccess.readwrite) prop_builder.SetSetMethod (typeB.DefineMethod ("set_" + prop.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] {propType})); } if (iface.Signals != null) foreach (NDesk.DBus.Introspection.Signal signal in iface.Signals) { //Type eventType = typeof (EventHandler); Type eventType = typeof (VoidHandler); EventBuilder event_builder = typeB.DefineEvent (signal.Name, EventAttributes.None, eventType); event_builder.SetAddOnMethod (typeB.DefineMethod ("add_" + signal.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] {eventType})); event_builder.SetRemoveOnMethod (typeB.DefineMethod ("remove_" + signal.Name, ifaceMethAttr | MethodAttributes.SpecialName, null, new Type[] {eventType})); } //apply InterfaceAttribute ConstructorInfo interfaceAttributeCtor = typeof (InterfaceAttribute).GetConstructor(new Type[] {typeof (string)}); CustomAttributeBuilder cab = new CustomAttributeBuilder (interfaceAttributeCtor, new object[] {iface.Name}); typeB.SetCustomAttribute (cab); }
private void GenerateEvents(List<string> usedNames, Type interfaceType, TypeBuilder tb, List<MethodInfo> propAccessors) { foreach (EventInfo eventInfo in interfaceType.GetEvents(BindingFlags.Instance | BindingFlags.Public)) { if (usedNames.Contains(eventInfo.Name)) { throw new NotSupportedException(string.Format("Error in interface {1}! Event name '{0}' already used in other child interface!", eventInfo.Name, interfaceType.Name)); //LOCSTR } else { usedNames.Add(eventInfo.Name); } EventBuilder eb = tb.DefineEvent(eventInfo.Name, eventInfo.Attributes, eventInfo.EventHandlerType); FieldBuilder ef = tb.DefineField(string.Concat("_", eventInfo.Name), eventInfo.EventHandlerType, FieldAttributes.Private); //add { MethodInfo addMethodInfo = eventInfo.GetAddMethod(); propAccessors.Add(addMethodInfo); MethodBuilder getMb = tb.DefineMethod(addMethodInfo.Name, MethodAttributes.Public | MethodAttributes.Virtual, typeof(void), new Type[] { eventInfo.EventHandlerType }); ILGenerator ilGenerator = getMb.GetILGenerator(); EmitEventAdd(ilGenerator, eventInfo, ef); tb.DefineMethodOverride(getMb, addMethodInfo); } //remove { MethodInfo removeMethodInfo = eventInfo.GetRemoveMethod(); propAccessors.Add(removeMethodInfo); MethodBuilder getMb = tb.DefineMethod(removeMethodInfo.Name, MethodAttributes.Public | MethodAttributes.Virtual, typeof(void), new Type[] { eventInfo.EventHandlerType }); ILGenerator ilGenerator = getMb.GetILGenerator(); EmitEventRemove(ilGenerator, eventInfo, ef); tb.DefineMethodOverride(getMb, removeMethodInfo); } } }
private static EventBuilder CreateEvent(TypeBuilder dest, EventInfo ev) { MethodBuilder add = null, remove = null; var mi = ev.GetAddMethod(); if (mi != null) { add = CreateMethodCopy(dest, mi); } mi = ev.GetRemoveMethod(); if (mi != null) { remove = CreateMethodCopy(dest, mi); } var evt = dest.DefineEvent(ev.Name, ev.Attributes, ev.EventHandlerType); if (add != null) { evt.SetAddOnMethod(add); } if (remove != null) { evt.SetRemoveOnMethod(remove); } return evt; }
private EventBuilder DefineEvent(TypeBuilder typeBuilder, Cci.IEventDefinition eventDef) { EventAttributes attrs = (EventAttributes)Cci.MetadataWriter.GetEventFlags(eventDef); Type type = ResolveType(eventDef.GetType(_context)); // Event, EventMap var eventBuilder = typeBuilder.DefineEvent(eventDef.Name, attrs, type); // MethodSemantics foreach (var accessor in eventDef.Accessors) { var accessorDef = (Cci.IMethodDefinition)accessor.AsDefinition(_context); var accessorBuilder = _methodBuilders[accessorDef]; if (accessor == eventDef.Adder) { eventBuilder.SetAddOnMethod(accessorBuilder); } else if (accessor == eventDef.Remover) { eventBuilder.SetRemoveOnMethod(accessorBuilder); } else if (accessor == eventDef.Caller) { eventBuilder.SetRaiseMethod(accessorBuilder); } else { eventBuilder.AddOtherMethod(accessorBuilder); } } return eventBuilder; }
void DefineEvent(TypeBuilder typeBuilder, Event node) { var builder = typeBuilder.DefineEvent(node.Name, EventAttributes.None, GetSystemType(node.Type)); builder.SetAddOnMethod(DefineEventMethod(typeBuilder, node.Add)); builder.SetRemoveOnMethod(DefineEventMethod(typeBuilder, node.Remove)); if (node.Raise != null) builder.SetRaiseMethod(DefineEventMethod(typeBuilder, node.Raise)); SetBuilder(node, builder); }
private static FieldBuilder AddEvent(TypeBuilder typeBuilder, string eventName, Type eventHandlerType) { EventBuilder eventBuilder = typeBuilder.DefineEvent(eventName, EventAttributes.None, eventHandlerType); FieldBuilder backingField = typeBuilder.DefineField(eventName, eventHandlerType, FieldAttributes.Private); MethodBuilder addMethod = typeBuilder.DefineMethod("add_" + eventName, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, CallingConventions.Standard, typeof(void), new [] { eventHandlerType }); ILGenerator generator = addMethod.GetILGenerator(); generator.DeclareLocal(eventHandlerType); generator.DeclareLocal(eventHandlerType); generator.DeclareLocal(eventHandlerType); generator.DeclareLocal(typeof(bool)); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldfld, backingField); generator.Emit(OpCodes.Stloc_0); Label loop = generator.DefineLabel(); generator.MarkLabel(loop); generator.Emit(OpCodes.Ldloc_0); generator.Emit(OpCodes.Stloc_1); generator.Emit(OpCodes.Ldloc_1); generator.Emit(OpCodes.Ldarg_1); generator.Emit(OpCodes.Call, typeof(Delegate).GetMethod("Combine", new []{typeof(Delegate), typeof(Delegate)})); generator.Emit(OpCodes.Castclass, eventHandlerType); generator.Emit(OpCodes.Stloc_2); generator.Emit(OpCodes.Ldarg_0); generator.Emit(OpCodes.Ldflda, backingField); generator.Emit(OpCodes.Ldloc_2); generator.Emit(OpCodes.Ldloc_1); MethodInfo m = GetGenericMethod(typeof(Interlocked), "CompareExchange", new [] { eventHandlerType }, new [] { eventHandlerType, eventHandlerType, eventHandlerType }); generator.Emit(OpCodes.Call, m); generator.Emit(OpCodes.Stloc_0); generator.Emit(OpCodes.Ldloc_0); generator.Emit(OpCodes.Ldloc_1); generator.Emit(OpCodes.Ceq); generator.Emit(OpCodes.Ldc_I4_0); generator.Emit(OpCodes.Ceq); generator.Emit(OpCodes.Stloc_3); generator.Emit(OpCodes.Ldloc_3); generator.Emit(OpCodes.Brtrue_S, loop); generator.Emit(OpCodes.Ldstr, "ADD..."); EmitConsoleWriteLine(generator); generator.Emit(OpCodes.Ret); MethodBuilder removeMethod = typeBuilder.DefineMethod("remove_" + eventName, MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, CallingConventions.Standard, typeof(void), new[] { eventHandlerType }); generator = removeMethod.GetILGenerator(); generator.Emit(OpCodes.Ldstr, "REMOVE..."); generator.Emit(OpCodes.Ret); eventBuilder.SetAddOnMethod(addMethod); eventBuilder.SetRemoveOnMethod(removeMethod); return backingField; }
/// <summary> /// Implements the specified event. /// </summary> /// <param name="typeBuilder">The type builder to use.</param> /// <param name="type">The type the event is defined on.</param> /// <param name="evt">The event to proxy.</param> /// <param name="methodMap">The implemented methods map.</param> protected virtual void ImplementEvent(TypeBuilder typeBuilder, Type type, EventInfo evt, IDictionary<string, MethodBuilder> methodMap) { MethodBuilder addOnMethod; methodMap.TryGetValue("add_" + evt.Name, out addOnMethod); MethodBuilder removeOnMethod; methodMap.TryGetValue("remove_" + evt.Name, out removeOnMethod); if (addOnMethod != null && removeOnMethod != null) { string eventName = (addOnMethod.IsPrivate) ? addOnMethod.DeclaringType.FullName + "." + evt.Name : evt.Name; EventBuilder eb = typeBuilder.DefineEvent( eventName, EventAttributes.None, evt.EventHandlerType); // set add/remove methods eb.SetAddOnMethod(addOnMethod); eb.SetRemoveOnMethod(removeOnMethod); } }
static void BuildEvent(TypeBuilder type, Type viewType, EventInfo eventInfo) { var addMethod = BuildEventAddMethod(type, viewType, eventInfo); var removeMethod = BuildEventRemoveMethod(type, viewType, eventInfo); if (eventInfo.EventHandlerType == null) { throw new ArgumentException(string.Format( CultureInfo.InvariantCulture, "The supplied event {0} from {1} does not have the event handler type specified.", eventInfo.Name, eventInfo.ReflectedType.Name), "eventInfo"); } var @event = type.DefineEvent( eventInfo.Name, eventInfo.Attributes, eventInfo.EventHandlerType); @event.SetAddOnMethod(addMethod); @event.SetRemoveOnMethod(removeMethod); }
void DefineEvent(TypeBuilder typeBuilder, Event node) { EventBuilder builder = typeBuilder.DefineEvent(node.Name, EventAttributes.None, GetSystemType(node.Type)); //MethodAttributes attribs = GetPropertyMethodAttributes(node); MethodAttributes baseAttributes = MethodAttributes.SpecialName; builder.SetAddOnMethod(DefineMethod(typeBuilder, node.Add, baseAttributes|GetMethodAttributes(node.Add))); builder.SetRemoveOnMethod(DefineMethod(typeBuilder, node.Remove, baseAttributes|GetMethodAttributes(node.Remove))); if (null != node.Raise) { builder.SetRaiseMethod(DefineMethod(typeBuilder, node.Raise, baseAttributes|GetMethodAttributes(node.Raise))); } SetBuilder(node, builder); }
public FieldBuilder BuildEvent(TypeBuilder type, MethodInfo method, Type delegateType) { EventBuilder e = type.DefineEvent("_" + method.Name, EventAttributes.None, delegateType); Type[] types = new Type[] { typeof(Delegate), typeof(Delegate) }; FieldBuilder field = type.DefineField("_" + method.Name, delegateType, FieldAttributes.Private); string[] nameprefixes = new string[] { "add", "remove" }; MethodInfo[] calleds = new MethodInfo[] { combin, remove }; MethodBuilder[] methods = new MethodBuilder[2]; for (int i = 0; i < 2; i++) { methods[i] = type.DefineMethod(nameprefixes[i] + "__" + method.Name, MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Private, typeof(void), new Type[] { delegateType }); ILGenerator gen = methods[i].GetILGenerator(); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldarg_0); gen.Emit(OpCodes.Ldfld, field); gen.Emit(OpCodes.Ldarg_1); gen.Emit(OpCodes.Call, calleds[i]); gen.Emit(OpCodes.Castclass, delegateType); gen.Emit(OpCodes.Stfld, field); gen.Emit(OpCodes.Ret); } e.SetAddOnMethod(methods[0]); e.SetRemoveOnMethod(methods[1]); return field; }