/// <summary>
/// Gets the event handler.
/// </summary>
/// <param name="instance">
/// The instance that is registering for the event notification.
/// </param>
/// <param name="info">
/// Event metadata about the event.
/// </param>
/// <returns>
/// The event handler.
/// </returns>
protected override Delegate GetHandler(object instance, EventInfo info)
{
MethodInfo methodMeta = ResolveHandlerMethod(
ReflectionUtils.TypeOfOrType(instance),
info.EventHandlerType,
InstanceEventHandlerValue.InstanceMethodFlags);
Delegate callback = null;
if (methodMeta.IsStatic)
{
// case insensitive binding to a static method on an (irrelevant) instance
callback = Delegate.CreateDelegate(
info.EventHandlerType,
methodMeta);
}
else
{
// case insensitive binding to an instance method on an instance
callback =
Delegate.CreateDelegate(
info.EventHandlerType,
instance,
MethodName,
true);
}
return callback;
}
/// <summary>
/// Wires the event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="event">The event.</param>
/// <param name="handler">The handler.</param>
public static void WireEvent(object sender, EventInfo @event, Action<object, EventArgs> handler)
{
@event.AddEventHandler(
sender,
Delegate.CreateDelegate(@event.EventHandlerType, handler.Target, handler.Method)
);
}
public EventBuilder(TypeBuilder toType, FieldInfo objBase, EventInfo parentEvent)
: base(toType, objBase)
{
ParentEvent = parentEvent;
if (!CompareExchange.ContainsKey(ParentEvent.EventHandlerType))
CompareExchange.TryAdd(ParentEvent.EventHandlerType, _CompareExchange.MakeGenericMethod(ParentEvent.EventHandlerType));
}
public static NameType TryGetName(TotemType dt, EventInfo ei, MethodInfo eventMethod, out string name)
{
name = ei.Name;
NameType res = dt.IsTotemType ? NameType.TotemEvent : NameType.Event;
return GetNameFromMethod(dt, eventMethod, res, ref name);
}
private static void GetDataForComInvocation(System.Reflection.EventInfo eventInfo, out Guid sourceIid, out int dispid)
{
object[] comEventInterfaces = eventInfo.DeclaringType.GetCustomAttributes(typeof(ComEventInterfaceAttribute), false);
if (comEventInterfaces == null || comEventInterfaces.Length == 0)
{
// TODO: event strings need to be localizable
throw new InvalidOperationException("event invocation for COM objects requires interface to be attributed with ComSourceInterfaceGuidAttribute");
}
if (comEventInterfaces.Length > 1)
{
// TODO: event strings need to be localizable
throw new System.Reflection.AmbiguousMatchException("more than one ComSourceInterfaceGuidAttribute found");
}
Type sourceItf = ((ComEventInterfaceAttribute)comEventInterfaces[0]).SourceInterface;
Guid guid = sourceItf.GUID;
System.Reflection.MethodInfo methodInfo = sourceItf.GetMethod(eventInfo.Name);
Attribute dispIdAttribute = Attribute.GetCustomAttribute(methodInfo, typeof(DispIdAttribute));
if (dispIdAttribute == null)
{
// TODO: event strings need to be localizable
throw new InvalidOperationException("event invocation for COM objects requires event to be attributed with DispIdAttribute");
}
sourceIid = guid;
dispid = ((DispIdAttribute)dispIdAttribute).Value;
}
public CallInfoCacheItem(EventInfo ei)
{
this.Call = ei.CreateDynamicFunc();
EI = ei;
MI = ei.EventHandlerType.GetMethod("Invoke");
SetParamInfo();
}
public DomEventInstance(DomNodeInstance node, EventInfo eventInfo)
{
Getter = new ClrFunctionInstance(node.Engine, (thisObject, arguments) => _function ?? JsValue.Null);
Setter = new ClrFunctionInstance(node.Engine, (thisObject, arguments) =>
{
if (_handler != null)
{
eventInfo.RemoveEventHandler(node.Value, _handler);
_handler = null;
_function = null;
}
if (arguments[0].Is<FunctionInstance>())
{
_function = arguments[0].As<FunctionInstance>();
_handler = (s, ev) =>
{
var sender = s.ToJsValue(node.Context);
var args = ev.ToJsValue(node.Context);
_function.Call(sender, new [] { args });
};
eventInfo.AddEventHandler(node.Value, _handler);
}
return arguments[0];
});
}
public void Init(string fullName, int flags, JsTypeFunction thisType, JsTypeFunction baseType, JsTypeFunction[] interfaces, JsTypeFunction[] typeArguments, FieldInfo[] fields, MethodInfo[] methods, ConstructorInfo[] constructors, PropertyInfo[] properties, EventInfo[] events, JsTypeFunction elementType, JsTypeFunction unconstructedType)
{
FullName = fullName;
typeFlags = (TypeFlags)flags;
// this.typeAttributes = typeAttributes;
this.thisType = thisType;
this.baseType = baseType;
this.interfaces = interfaces;
this.typeArguments = typeArguments;
this.fields = fields ?? new FieldInfo[0];
this.methods = methods ?? new MethodInfo[0];
this.properties = properties ?? new PropertyInfo[0];
this.constructors = constructors ?? new ConstructorInfo[0];
this.events = events ?? new EventInfo[0];
this.elementType = elementType;
this.unconstructedType = unconstructedType;
foreach (var field in this.fields)
field.declaringType = this;
foreach (var method in this.methods)
method.declaringType = this;
foreach (var property in this.properties)
{
property.declaringType = this;
if (property.GetMethod != null)
property.GetMethod.declaringType = this;
if (property.SetMethod != null)
property.SetMethod.declaringType = this;
}
foreach (var constructor in this.constructors)
constructor.declaringType = this;
}
private EventBuilder CreateProxyEventBuilder(TypeBuilder typeBuilder, EventInfo contractEvent)
{
var builder = typeBuilder.DefineEvent(contractEvent.Name, contractEvent.Attributes,
contractEvent.EventHandlerType);
return builder;
}
private void BuildPropertyProxy(TypeBuilder typeBuilder, EventInfo contractEvent)
{
var builder = CreateProxyEventBuilder(typeBuilder, contractEvent);
BuildRemover(typeBuilder, contractEvent, builder);
BuildAdder(typeBuilder, contractEvent, builder);
}
public DocumentedEvent(Identifier name, XmlNode xml, EventInfo ev, Type targetType)
{
Name = name;
Xml = xml;
Event = ev;
TargetType = targetType;
}
internal WorkflowMessageEventHandler(Type proxiedType, EventInfo eventInfo, IDeliverMessage enqueueWrapper)
{
this.proxiedType = proxiedType;
this.eventName = eventInfo.Name;
this.eventHandlerType = eventInfo.EventHandlerType;
this.enqueueWrapper = enqueueWrapper;
}
internal EventInterceptionAspectDefinition(IAspect aspect, Type aspectDeclaringType, EventInfo @event, MemberInfo target)
{
Aspect = aspect;
Member = @event;
Target = target;
AspectDeclaringType = aspectDeclaringType;
}
public ScriptObjectEventInfo (string name, ScriptObject callback, EventInfo ei)
{
Name = name;
Callback = callback;
EventInfo = ei;
NativeMethods.html_object_retain (PluginHost.Handle, Callback.Handle);
}
private static void WriteExtensionMethod(Type type, EventInfo eventInfo, StringBuilder builder, SortedSet<string> usingNamespaces)
{
var eventType = eventInfo.EventHandlerType.Name; // e.g. MouseEventHandler
var eventName = eventInfo.Name; // e.g. MouseMove
var eventArgs = eventInfo.EventHandlerType.GetMethod("Invoke").GetParameters()[1].ParameterType; // e.g. MouseEventArgs
// TODO: Is event args ever generic? Might need to cope with that
if (eventInfo.EventHandlerType.IsGenericType)
{
switch (eventInfo.EventHandlerType.Name)
{
case "ReturnEventHandler`1":
eventType = string.Format("ReturnEventHandler<{0}>", eventArgs.Name);
break;
case "RoutedPropertyChangedEventHandler`1":
eventType = string.Format("RoutedPropertyChangedEventHandler<{0}>", eventArgs.Name);
break;
case "EventHandler`1":
eventType = string.Format("EventHandler<{0}>", eventArgs.Name);
break;
default:
throw new Exception("Can't cope with other generic types");
}
}
usingNamespaces.Add(eventInfo.EventHandlerType.Namespace);
usingNamespaces.Add(eventArgs.Namespace);
builder.AppendLine(string.Format("\t\tpublic static IObservable<EventPattern<{0}>> {1}Observer(this {2} This)", eventArgs.Name, eventName, type.Name));
builder.AppendLine("\t\t{");
builder.AppendLine(string.Format("\t\t\treturn Observable.FromEventPattern<{0}, {1}>(h => This.{2} += h, h => This.{2} -= h);", eventType, eventArgs.Name, eventName));
builder.AppendLine("\t\t}");
}
/// <summary>
///
/// </summary>
/// <param name="namespace"></param>
/// <param name="name"></param>
/// <param name="isGenericType"></param>
/// <param name="basetype"></param>
/// <param name="isValueType"></param>
/// <param name="isByRef"></param>
/// <param name="isEnum"></param>
/// <param name="isPointer"></param>
/// <param name="ElementType">
/// Type of the object encompassed or referred to by the current array, pointer or reference type. It's what GetElementType() will return.
/// Specify null when it is not needed
/// </param>
public ArtificialType(string @namespace, string name, bool isGenericType, Type basetype,
bool isValueType, bool isByRef, bool isEnum, bool isPointer, Type ElementType,
bool isInterface,
bool isAbstract,
Type MReturnSynType
)
{
_Name = name;
_Namespace = @namespace;
_IsGenericType = isGenericType;
_BaseType = basetype;
_IsValueType = isValueType;
_IsByRef = isByRef;
_IsEnum = isEnum;
_IsPointer = isPointer;
_IsInterface = isInterface;
_IsAbstract = isAbstract;
_Method1 = new ArtificialMethodInfo("M", this, typeof(int[]), MethodAttributes.Public | (_IsAbstract ? MethodAttributes.PrivateScope | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.Abstract : MethodAttributes.Static), null, false);
_Method2 = new ArtificialMethodInfo("RaiseEvent1", this, typeof(void), MethodAttributes.Public | (_IsAbstract ? MethodAttributes.Abstract : 0), null, false);
_Method3 = new ArtificialMethodInfo("M1", this, this, MethodAttributes.Public | MethodAttributes.Static | (_IsAbstract ? MethodAttributes.Abstract : 0), new[] { new ArtificialParamInfo("x1", basetype, false) }, false);
_Method4 = new ArtificialMethodInfo("M2", this, this, MethodAttributes.Public | MethodAttributes.Static | (_IsAbstract ? MethodAttributes.Abstract : 0), new[] { new ArtificialParamInfo("y1", this, false) }, false);
_Property1 = new ArtificialPropertyInfo("StaticProp1", this, typeof(decimal), true, false);
_Property2 = new ArtificialPropertyInfo("StaticProp2", this, typeof(System.Tuple<int, int, int, int, int, int, int, System.Tuple<int, int, int>>), true, false);
_Property3 = new ArtificialPropertyInfo("StaticProp3", this, typeof(System.Tuple<int, int, int>), true, false);
_Event1 = new ArtificalEventInfo("Event1", this, typeof(EventHandler));
_Ctor1 = new ArtificialConstructorInfo(this, new ParameterInfo[] {} ); // parameter-less ctor
_ElementType = ElementType;
}
internal CLSEvent(String name, Type type, EventInfo eventInfo, Boolean isStatic)
{
this.isStatic = isStatic;
this.eventInfo = eventInfo;
this.type = type;
this.name = name;
}
public RemoveEventDecoratorWeaver(IEventTypeBuilder eventTypeBuilder, EventInfo @event, IWeavingSettings weavingSettings)
: base(@event.GetRemoveMethod(), weavingSettings)
{
MethodEndWeaver = new MethodEndWeaver();
MethodScopeWeaver = new RemoveEventDecoratorScopeWeaver(method, weavingSettings);
MethodDefintionWeaver = new RemoveEventMethodSignatureWeaver(eventTypeBuilder, weavingSettings.TypeDefinition);
}
internal EventMonitor(IRoutedMessageHandler messageHandler, EventInfo eventInfo)
{
_messageHandler = messageHandler;
_triggersToNotify = new List<IMessageTrigger>();
EventHelper.WireEvent(messageHandler.Unwrap(), eventInfo, ChangedEventHandler);
}
public DependencyPropertyProxy(object context, PropertyInfo property, EventInfo updateEvent)
: base(context, updateEvent, _triggerMethodInfo)
{
_context = context;
_property = property;
DetectProperty();
}
internal EventHookupHelper(string handlerName, EventInfo eventInfo,
string scriptVirtualPath)
{
_handlerName = handlerName;
_eventInfo = eventInfo;
_scriptVirtualPath = scriptVirtualPath;
}
// ReSharper restore UnusedMember.Local
public override void RuntimeInitialize( EventInfo eventInfo )
{
// An event always has a declaring type.
Contract.Assume( eventInfo.DeclaringType != null );
base.RuntimeInitialize( eventInfo );
Type declaringType = eventInfo.DeclaringType;
_declaringGenericType = declaringType.IsGenericType ? declaringType.GetGenericTypeDefinition() : declaringType;
_addEmptyEventHandlers = new CachedDictionary<Type, Action<object>>( type =>
{
// Find the type in which the constructor is defined.
// Needed since events can be private, and those wouldn't be returned otherwise, even when searching a flattened hierarchy.
Type baseType = type.GetMatchingGenericType( _declaringGenericType );
EventInfo runtimeEvent = baseType.GetEvents( ReflectionHelper.ClassMembers ).Where( e => e.Name == eventInfo.Name ).First();
MethodInfo delegateInfo = DelegateHelper.MethodInfoFromDelegateType( runtimeEvent.EventHandlerType );
ParameterExpression[] parameters = delegateInfo.GetParameters().Select( p => Expression.Parameter( p.ParameterType ) ).ToArray();
Delegate emptyDelegate
= Expression.Lambda( runtimeEvent.EventHandlerType, Expression.Empty(), "EmptyDelegate", true, parameters ).Compile();
// Create the delegate which adds the empty handler to an instance.
MethodInfo addMethod = runtimeEvent.GetAddMethod( true );
if ( addMethod.IsPublic )
{
return instance => runtimeEvent.AddEventHandler( instance, emptyDelegate );
}
return instance => addMethod.Invoke( instance, new object[] { emptyDelegate } );
} );
}
protected Delegate CreateEventHandler(object target, View view, MethodMapping methodMapping, out EventInfo evnt)
{
Delegate del = null;
evnt = null;
if (view != null)
{
evnt = view.GetType().GetEvent(methodMapping.Attribute.EventName);
if (evnt != null)
{
try
{
del = CreateDelegate(target, methodMapping, evnt);
}
catch (Exception ex)
{
Geneticist.HandleError(
ex,
"Error creating delegate from '{0}' for event '{1}'.",
methodMapping.Method.Name,
methodMapping.Attribute.EventName);
}
}
else
{
Geneticist.HandleError(
"Unable to find event '{0}' for method '{1}'.",
methodMapping.Attribute.EventName,
methodMapping.Method.Name);
}
}
return del;
}
private void UnsubscribeEvents(HandshakingInfo subscriber)
{
foreach (var eventInfor in subscriber.UnsubscribeEventList)
{
foreach (var dic in eventInfor.Value)
{
if (dic.Value)
{
object qObj = ServerDictionaries.GetObjectFromTheDictionary(eventInfor.Key);
System.Reflection.EventInfo ei = qObj.GetType().GetEvent(dic.Key);
// Find corresponding CQG delegate
Type delType = QueryHandler.FindDelegateType(QueryHandler.CQGAssembly, dic.Key);
// Instantiate the delegate with our own handler
string handlerName = string.Concat("_ICQGCELEvents_", dic.Key, "EventHandlerImpl");
MethodInfo handlerInfo = typeof(CQGEventHandlers).GetMethod(handlerName);
Delegate d = Delegate.CreateDelegate(delType, handlerInfo);
// Unsubscribe our handler from CQG event
ei.RemoveEventHandler(qObj, d);
}
}
}
}
public ReflectedEvent(EventIdentifier name, EventInfo ev, Type targetType)
: base(name, null, ev, targetType)
{
DeclaringName = ev.DeclaringType != targetType
? IdentifierFor.Event(ev, ev.DeclaringType)
: name;
}
/// <summary>
/// Remove all the eventhandlers from StateChanged event of original store (<see cref="_store"/>), and return them
/// as a combined multi cast delegate.
/// <a href="https://stackoverflow.com/a/16089998/605113">Reference</a>
/// </summary>
/// <param name="originalStore"></param>
/// <returns>Combined Delegate of StateChanged event handlers attached to original store.</returns>
private Delegate ShiftAllEvents(IStore <TState> originalStore)
{
// @ref: https://stackoverflow.com/a/16089998/605113
Type theType = originalStore.GetType();
Delegate finalDelegate = null;
//Even though the events are public, the FieldInfo associated with them is private
foreach (System.Reflection.FieldInfo field in theType.GetTypeInfo().DeclaredFields)
{
//eventInfo will be null if this is a normal field and not an event.
System.Reflection.EventInfo eventInfo = theType.GetTypeInfo().GetDeclaredEvent(field.Name);
if (eventInfo != null && field.Name == nameof(StateChanged))
{
MulticastDelegate multicastDelegate = field.GetValue(originalStore) as MulticastDelegate;
if (multicastDelegate != null)
{
List <Delegate> oldHandlers = new List <Delegate>();
foreach (Delegate @delegate in multicastDelegate.GetInvocationList())
{
eventInfo.RemoveEventHandler(originalStore, @delegate);
oldHandlers.Add(@delegate);
}
if (oldHandlers.Count > 0)
{
finalDelegate = Delegate.Combine(oldHandlers.ToArray());
}
}
}
}
return(finalDelegate);
}
public static void RaiseEventImpl(object instance, EventInfo evt, object[] args)
{
if (evt == null)
throw new MockException("Unable to deduce which event was specified in the parameter.");
if (args.Length == 1
&& (evt.EventHandlerType.IsGenericType && evt.EventHandlerType.GetGenericTypeDefinition() == typeof(EventHandler<>)
|| evt.EventHandlerType == typeof(EventHandler)
|| args[0] is EventArgs)
)
{
args = new[] { instance, args[0] };
}
if (!(instance is IMockMixin))
{
var mockMixin = MocksRepository.GetMockMixin(instance, evt.DeclaringType);
if (mockMixin != null)
instance = mockMixin;
}
var mixin = instance as IEventsMixin;
if (mixin != null)
{
mixin.RaiseEvent(evt, args);
}
else
{
MockingUtil.RaiseEventThruReflection(instance, evt, args);
}
}
public CallInfoCacheItem(MethodInfo mi)
{
MI = mi;
this.Call = mi.CreateDynamicFunc();
EI = null;
SetParamInfo();
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyPublication"/> class.
/// </summary>
/// <param name="topic">The event topic this publication belongs to.</param>
/// <param name="publisher">The publisher.</param>
/// <param name="eventInfo">The <see cref="EventInfo"/> of the publisher that registers this event topic.</param>
/// <param name="handlerRestriction">The handler restriction.</param>
/// <param name="publicationMatchers">The publication matchers.</param>
public PropertyPublication(
IEventTopic topic,
object publisher,
EventInfo eventInfo,
HandlerRestriction handlerRestriction,
IList<IPublicationMatcher> publicationMatchers) :
base(topic, publisher, handlerRestriction, publicationMatchers)
{
this.eventInfo = eventInfo;
if (this.eventInfo.EventHandlerType == null)
{
throw new Exception("EventHandlerType on published event must not be null (internal EventBroker failure).");
}
ThrowIfInvalidEventHandler(this.eventInfo);
ThrowIfEventIsStatic(this.eventInfo);
this.eventArgsType = this.eventInfo.EventHandlerType == typeof(EventHandler)
? typeof(EventArgs)
: this.eventInfo.EventHandlerType.GetGenericArguments()[0];
Delegate handler = Delegate.CreateDelegate(
this.eventInfo.EventHandlerType,
this,
GetType().GetMethod("PublicationHandler"));
this.eventInfo.AddEventHandler(publisher, handler);
}
public EventPropertyDescriptor(object component, System.Reflection.EventInfo eventInfo, System.ComponentModel.EventHandlerList eventHandlerList) : base(eventInfo.Name)
{
this.component = component;
this.eventInfo = eventInfo;
this.eventHandlerList = eventHandlerList;
this.converter = new EventInfoConverter(this);
}
private static DynamicMethodDelegate GetEndTrigger(EventInfo info)
{
EndTriggerAttribute triggerAttribute = Enumerable.FirstOrDefault<object>((IEnumerable<object>) info.GetCustomAttributes(typeof (EndTriggerAttribute), false)) as EndTriggerAttribute;
if (triggerAttribute == null)
return (DynamicMethodDelegate) null;
else
return ReflectionHelper.CreateDelegate((MethodBase) info.DeclaringType.GetEvent(triggerAttribute.Trigger).GetAddMethod());
}
protected HandlerNotFoundException(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
: base(info, context)
{
handler_name = info.GetString("HandlerName");
signal_name = info.GetString("SignalName");
evnt = info.GetValue("Event", typeof(System.Reflection.EventInfo)) as System.Reflection.EventInfo;
delegate_type = info.GetValue("DelegateType", typeof(Type)) as Type;
}
internal CompositeRaiseEventWeaver(IEventTypeBuilder eventTypeBuilder, EventInfo @event, MethodInfo method, IAspectDefinitionCollection aspectDefinitions, IAspectWeavingSettings aspectWeavingSettings)
: base(eventTypeBuilder, method, aspectDefinitions, aspectWeavingSettings)
{
var typeBuilder = (IAspectTypeDefinition)aspectWeavingSettings.WeavingSettings.TypeDefinition;
var eventFieldBuilder = typeBuilder.GetEventBrokerFielTypeDefinition(@event);
methodSignatureWeaver = new RaiseEventMethodSignatureWeaver(eventTypeBuilder, typeBuilder, eventFieldBuilder);
}
/*----------------------------------------------------------------------------------------*/
#region Constructors
/// <summary>
/// Initializes a new instance of the <see cref="PublicationDirective"/> class.
/// </summary>
/// <param name="channel">The name of the channel that is to be published to.</param>
/// <param name="evt">The event that will be published to the channel.</param>
public PublicationDirective(string channel, EventInfo evt)
{
Ensure.ArgumentNotNullOrEmptyString(channel, "channel");
Ensure.ArgumentNotNull(evt, "evt");
_channel = channel;
_evt = evt;
}
public CompositeEventWeaver(ITypeDefinition typeDefinition, EventInfo @event)
{
EventName = @event.Name;
EventType = @event.EventHandlerType;
lazyEventBuilder = new Core.Lib.Lazy<EventBuilder>(() => {
return typeDefinition.TypeBuilder.DefineEvent(@event);
});
}
public override void Initialize_PreGame()
{
// caching the reflection stuff should speed up stuff at least a little bit. Reflection isn't very fast, anyway. Try to avoid it in hot code.
tabControlVarInfo = typeof(Game.GUI.TabbedWindow).GetField("mTabControl", BindingFlags.NonPublic | BindingFlags.Instance);
tabControlEventInfo = typeof(Game.GUI.Controls.TabControl).GetEvent("PageChanged");
tabControlPanelListVarInfo = typeof(Game.GUI.TabbedWindow).GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Single(field => field.FieldType == typeof(List <Game.GUI.TabbedWindowPanel>));
controlScrollBarFieldsInfoList = typeof(Game.GUI.Controls.Container).GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Where(field => field.FieldType == typeof(Game.GUI.Controls.ScrollBar)).ToArray();
scrollBarOrientationFieldInfo = typeof(Game.GUI.Controls.ScrollBar).GetFields(BindingFlags.NonPublic | BindingFlags.Instance).Single(field => field.FieldType == typeof(Game.GUI.Controls.Orientation));
}
public HandlerNotFoundException(string message, string handler_name, string signal_name,
System.Reflection.EventInfo evnt, Type delegate_type)
: base((message != null) ? message : "No handler " + handler_name + " found for signal " + signal_name,
null)
{
this.handler_name = handler_name;
this.signal_name = signal_name;
this.evnt = evnt;
this.delegate_type = delegate_type;
}
public HandlerNotFoundException(string handler_name, string signal_name,
System.Reflection.EventInfo evnt, Type delegate_type, Exception inner)
: base("No handler " + handler_name + " found for signal " + signal_name,
inner)
{
this.handler_name = handler_name;
this.signal_name = signal_name;
this.evnt = evnt;
this.delegate_type = delegate_type;
}
Event LoadEvent(System.Reflection.EventInfo refEvent)
{
Event eventObject = new Event
{
Name = refEvent.Name,
IsStatic = refEvent.GetAddMethod().IsStatic,
EventHandlerType = GetTypeFullName(refEvent.EventHandlerType),
Attributes = refEvent.Attributes,
};
return(eventObject);
}
public void PrintEvent(SysRef.EventInfo eventInfo)
{
if ((_flags & SignaturePrintingFlags.IgnoreMemberOwner) != SignaturePrintingFlags.IgnoreMemberOwner)
{
PrintType(eventInfo.DeclaringType);
_builder.Append("::");
}
PrintIdentifier(eventInfo.Name);
_builder.Append(" : ");
PrintType(eventInfo.EventHandlerType, false);
}
internal static System.Delegate CreateEventHandlerDelegate <TDelegate>(System.Reflection.EventInfo evt, TDelegate d)
{
var handlerType = evt.EventHandlerType;
var eventParams = handlerType.GetMethod("Invoke").GetParameters();
ParameterExpression[] parameters = eventParams.Select(p => Expression.Parameter(p.ParameterType, p.Name)).ToArray();
MethodCallExpression body = Expression.Call(Expression.Constant(d), d.GetType().GetMethod("Invoke"), parameters);
var lambda = Expression.Lambda(body, parameters);
// Diagnostics.Debug.Assert(false, lambda.ToString());
return(System.Delegate.CreateDelegate(handlerType, lambda.Compile(), "Invoke", false));
}
public Event(Class declaringType, SR.EventInfo tinfo)
{
this.declaringType = declaringType;
ModifierEnum mod = (ModifierEnum)0;
modifiers = mod;
this.FullyQualifiedName = tinfo.Name;
returnType = new ReturnType(tinfo.EventHandlerType);
this.region = Class.GetRegion();
this.bodyRegion = Class.GetRegion();
LoadXml(declaringType);
}
public IDebuggerEvent GetEvent(SR.EventInfo evt) => debugger.Dispatcher.UI(() => {
var comparer = new TypeComparer();
foreach (var e in GetEvents(evt.Name, true))
{
var eventType = e.EventType;
// EventType currently always returns null
if (eventType == null)
{
return(e);
}
if (comparer.Equals(eventType, evt.EventHandlerType))
{
return(e);
}
}
return(null);
});
/// <summary>
/// Hack for compatibility RabbitMQ.Client library between 3.4.x and 3.5.x versions
/// ConnectionShutdownEventHandler replaced by Eventhandler<ShutdownEventArgs> - https://github.com/rabbitmq/rabbitmq-dotnet-client/commit/84ca5552a338a86c9af124331adca230accf3be3
/// using reflection for understand, what type of delegate we must use for IConnection.ConnectionShutdown:
/// - EventHandler<ShutdownEventArgs> for 3.5.x version
/// - ConnectionShutdownEventHandler for 3.4.x and early version
/// </summary>
private void PrepareConnectionShutdownEventHandler()
{
System.Reflection.EventInfo connectionShutdownEventInfo = typeof(IConnection).GetEvent("ConnectionShutdown");
_connectionShutdownEventAddMethod = connectionShutdownEventInfo.GetAddMethod();
Type delegateType = connectionShutdownEventInfo.EventHandlerType;
System.Reflection.MethodInfo shutdownAmqpMethodInfo = null;
if (delegateType.IsConstructedGenericType && delegateType.GetGenericTypeDefinition() == typeof(EventHandler <>))
{
shutdownAmqpMethodInfo = typeof(RabbitMQ).GetMethod("ShutdownAmqp35", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
}
else
{
shutdownAmqpMethodInfo = typeof(RabbitMQ).GetMethod("ShutdownAmqp", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
}
_connectionShutdownEventHandler = shutdownAmqpMethodInfo.CreateDelegate(delegateType, this);
}
/// <summary>
/// Add back all events from sourceDelegate to StateChanged event of original store targetStore.
/// </summary>
/// <param name="sourceDelegate">Delegate which holds all the event handlers. This is returned by <see cref="ShiftAllEvents(IStore{TState})"/></param>
/// <param name="targetStore">Store to which StateChanged event handlers needs to be added back.</param>
private void UnShiftAllEvents(Delegate sourceDelegate, IStore <TState> targetStore)
{
Type theType = targetStore.GetType();
foreach (System.Reflection.FieldInfo field in theType.GetTypeInfo().DeclaredFields)
{
System.Reflection.EventInfo eventInfo = theType.GetTypeInfo().GetDeclaredEvent(field.Name);
if (eventInfo != null && field.Name == nameof(StateChanged))
{
MulticastDelegate multicastDelegate = sourceDelegate as MulticastDelegate;
if (multicastDelegate != null)
{
List <Delegate> oldHandlers = new List <Delegate>();
foreach (Delegate @delegate in multicastDelegate.GetInvocationList())
{
eventInfo.AddEventHandler(targetStore, @delegate);
Delegate.Remove(multicastDelegate, @delegate);
}
}
}
}
}
public ComAwareEventInfo(Type type, string eventName)
{
_innerEventInfo = type.GetEvent(eventName);
}
public override CXXEventInfo Create(CXXTypeInfo declaringType, System.Reflection.EventInfo eventInfo)
{
return(EventCache.GetOrAdd(eventInfo, e => new CXXEventInfo(this, declaringType, e)));
}
private IEnumerable <string> GenerateEvent(short methodID, System.Reflection.EventInfo eventInfo)
{
var privateEvent = $"_{eventInfo.Name}";
var codeLines = new List <string>();
codeLines.Add($"private event EventHandler<{eventInfo.ArgsTypeName()}> {privateEvent};");
codeLines.Add($"public event EventHandler<{eventInfo.ArgsTypeName()}> {eventInfo.Name}");
codeLines.Add("{");
codeLines.Add("add{");
codeLines.Add($"Add_{eventInfo.Name}();");
codeLines.Add($"{privateEvent} += value;");
codeLines.Add("}");
codeLines.Add("remove{");
codeLines.Add($"Remove_{eventInfo.Name}();");
codeLines.Add($"{privateEvent} -= value;");
codeLines.Add("}");
codeLines.Add("}");
codeLines.Add($"private void Add_{eventInfo.Name}()");
codeLines.Add("{");
codeLines.Add($"if ({privateEvent} != null) return;");
if (OutputDebug)
{
var msg = $"proxy: add_event {eventInfo.Name} id={methodID}";
codeLines.Add($"System.Console.WriteLine(\"{msg}\");");
}
codeLines.Add("using var stream = new MemoryStream();");
codeLines.Add($"_proxyItem.SendCallRequest({methodID}, stream.ToArray());");
codeLines.Add("}");
codeLines.Add($"private void Remove_{eventInfo.Name}()");
codeLines.Add("{");
codeLines.Add($"if ({privateEvent} == null) return;");
if (OutputDebug)
{
var msg = $"proxy: remove_event {eventInfo.Name} id={methodID}";
codeLines.Add($"System.Console.WriteLine(\"{msg}\");");
}
codeLines.Add("try {");
codeLines.Add("using var stream = new MemoryStream();");
codeLines.Add($"_proxyItem.SendCallRequest({methodID + 1}, stream.ToArray());");
codeLines.Add("} catch {}"); //all exceptions need be caught here
codeLines.Add("}");
codeLines.Add($"private void Fire_{eventInfo.Name}(Stream dataStream)");
codeLines.Add("{");
if (OutputDebug)
{
var msg = $"proxy: on_event {eventInfo.Name} id={methodID}";
codeLines.Add($"System.Console.WriteLine(\"{msg}\");");
}
codeLines.Add("var serializer = new Serializer(dataStream);");
var argType = eventInfo.EventHandlerType.GenericTypeArguments[0];
codeLines.Add($"var args = {SerializeStatement.DeserializeObject(argType)}");
codeLines.Add($"var handler = {privateEvent};");
codeLines.Add($"if (handler != null) handler(this, args);");
codeLines.Add("}");
return(codeLines);
}
IEventInfo IMetadataProvider.Create(ITypeInfo declaringType, System.Reflection.EventInfo eventInfo)
{
return(Create((TTypeInfo)declaringType, eventInfo));
}
public static System.Reflection.MethodInfo GetAddMethod(System.Reflection.EventInfo eventInfo, bool nonPublic)
{
throw null;
}
public static System.Reflection.MethodInfo GetRemoveMethod(System.Reflection.EventInfo eventInfo)
{
throw null;
}
private static void AddLoggingListener(ref EventController logController, object component, System.Reflection.EventInfo eventInfo, EventActionEnum action)
{
if (logController == null)
{
logController = ClassGenerator.Instance.GenerateHandler(eventInfo);
}
if (!logController.IsAttached)
{
logController.Attach(component, eventInfo, action);
}
ObjectEditor.Instance.ActiveEditor.ShowToolsWindow(ToolWindowEnum.EventLog);
}
// Main query processing method
public void ProcessQuery(QueryInfo query)
{
// Object where the data obtained after query execution is placed
// This object will be sent to the DB
AnswerInfo answer;
// Get a name of a symbol if it's CQGTimedBarsRequestClass object's request
// and show it in MiniMonitor form
if (query.ObjectType == "CQGTimedBarsRequestClass")
{
object qObj = UsedObjs.Contains(query.ObjectKey) ? UsedObjs[query.ObjectKey] : ServerDictionaries.GetObjectFromTheDictionary(query.ObjectKey);
string instrName = (string)qObj.GetType().InvokeMember("Symbol",
BindingFlags.GetProperty, null, qObj, null);
if (!DCMiniMonitor.symbolsList.Contains(instrName))
{
DCMiniMonitor.symbolsList.Add(instrName);
Program.MiniMonitor.SymbolsListsUpdate();
}
}
// Handling of the request depending on its kind
switch (query.QueryType)
{
case QueryType.CallCtor:
{
try
{
string key;
// Handling of the ctor calling request and creation of an object depending on its type
switch (query.MemberName)
{
// Handling of CQGCEL ctor calling request
case "CQG.CQGCELClass":
key = CqgDataManagement.CEL_key;
break;
// Common case
default:
object[] args = Core.GetArgsIntoArrayFromTwoDicts(query.ArgKeys, query.ArgValues);
object qObj = CQGAssm.CreateInstance(query.MemberName, false,
BindingFlags.CreateInstance, null, args, null, null);
key = Core.CreateUniqueKey();
ServerDictionaries.PutObjectToTheDictionary(key, qObj);
UsedObjs.Add(key, qObj);
break;
}
answer = new AnswerInfo(query.QueryKey, query.ObjectKey, query.MemberName, valueKey: key);
PushAnswerAndDeleteQuery(answer);
}
catch
{
try
{
AutoGenQueryProcessing(query);
}
catch (Exception ex)
{
answer = CreateExceptionAnswer(ex, query);
PushAnswerAndDeleteQuery(answer);
}
}
}
break;
case QueryType.CallDtor:
{
if (query.ObjectKey != CqgDataManagement.CEL_key)
{
UsedObjs.Remove(query.ObjectKey);
ServerDictionaries.RemoveObjectFromTheDictionary(query.ObjectKey);
}
// Remove name of a symbol if it's CQG.CQGTimedBarsRequest object deleting
// from MiniMonitor form
if (query.MemberName == "CQG.CQGTimedBarsRequest")
{
object qObj = UsedObjs.Contains(query.ObjectKey) ? UsedObjs[query.ObjectKey] : ServerDictionaries.GetObjectFromTheDictionary(query.ObjectKey);
string symbName = (string)qObj.GetType().InvokeMember("Symbol",
BindingFlags.GetProperty, null, qObj, null);
DCMiniMonitor.symbolsList.Remove(symbName);
Program.MiniMonitor.SymbolsListsUpdate();
}
answer = new AnswerInfo(query.QueryKey, query.ObjectKey, query.MemberName, value: true);
PushAnswerAndDeleteQuery(answer);
}
break;
case QueryType.GetProperty:
{
object qObj = UsedObjs.Contains(query.ObjectKey) ? UsedObjs[query.ObjectKey] : ServerDictionaries.GetObjectFromTheDictionary(query.ObjectKey);
object[] args = Core.GetArgsIntoArrayFromTwoDicts(query.ArgKeys, query.ArgValues);
try
{
// Getting of property value
var propV = qObj.GetType().InvokeMember(query.MemberName, BindingFlags.GetProperty, null, qObj, args);
// Checking type of property value and returning value or value key
// (second, if it's not able to be transmitted through the database)
answer = Core.IsSerializableType(propV.GetType()) ?
CreateValAnswer(query.QueryKey, query.ObjectKey, query.MemberName, propV) :
CreateKeyAnswer(query.QueryKey, query.ObjectKey, query.MemberName, propV);
PushAnswerAndDeleteQuery(answer);
}
catch
{
try
{
AutoGenQueryProcessing(query);
}
catch (Exception ex)
{
answer = CreateExceptionAnswer(ex, query);
PushAnswerAndDeleteQuery(answer);
}
}
}
break;
case QueryType.SetProperty:
{
object qObj = UsedObjs.Contains(query.ObjectKey) ? UsedObjs[query.ObjectKey] : ServerDictionaries.GetObjectFromTheDictionary(query.ObjectKey);
object[] args = Core.GetArgsIntoArrayFromTwoDicts(query.ArgKeys, query.ArgValues);
if (string.Concat(qObj.GetType()) == "CQG.CQGTimedBarsRequest" && query.MemberName == "Symbol")
{
DCMiniMonitor.symbolsList.Add(string.Concat(args[0]));
Program.MiniMonitor.SymbolsListsUpdate();
}
try
{
// Setting of property value
qObj.GetType().InvokeMember(query.MemberName, BindingFlags.SetProperty, null, qObj, args);
answer = new AnswerInfo(query.QueryKey, query.ObjectKey, query.MemberName, value: true);
PushAnswerAndDeleteQuery(answer);
}
catch
{
try
{
AutoGenQueryProcessing(query);
}
catch (Exception ex)
{
answer = CreateExceptionAnswer(ex, query);
PushAnswerAndDeleteQuery(answer);
}
}
}
break;
case QueryType.CallMethod:
{
// Handling of Shutdown method calling by CQGCEL object. This method has not be called from client applications
if (query.MemberName == "Shutdown")
{
var returnKey = "true";
answer = new AnswerInfo(query.QueryKey, query.ObjectKey, query.MemberName, valueKey: returnKey);
PushAnswerAndDeleteQuery(answer);
break;
}
object qObj = UsedObjs.Contains(query.ObjectKey) ? UsedObjs[query.ObjectKey] : ServerDictionaries.GetObjectFromTheDictionary(query.ObjectKey);
object[] args = Core.GetArgsIntoArrayFromTwoDicts(query.ArgKeys, query.ArgValues);
try
{
object returnV;
bool isGetter = query.MemberName.StartsWith("get_");
bool isSetter = query.MemberName.StartsWith("set_");
if (isGetter || isSetter)
{
// Access property instead of calling method
string propName = query.MemberName.Substring(4);
BindingFlags invokeAttr = isGetter ? BindingFlags.GetProperty : BindingFlags.SetProperty;
returnV = qObj.GetType().InvokeMember(propName, invokeAttr, null, qObj, args);
}
else
{
returnV = qObj.GetType().InvokeMember(query.MemberName, BindingFlags.InvokeMethod, null, qObj, args);
}
if (!object.ReferenceEquals(returnV, null))
{
// Handling method call request depending of return value type
answer = Core.IsSerializableType(returnV.GetType()) ?
CreateValAnswer(query.QueryKey, query.ObjectKey, query.MemberName, returnV) :
CreateKeyAnswer(query.QueryKey, query.ObjectKey, query.MemberName, returnV);
}
else
{
// Handling void method call
var returnKey = "true";
answer = new AnswerInfo(query.QueryKey, query.ObjectKey, query.MemberName, valueKey: returnKey);
}
PushAnswerAndDeleteQuery(answer);
}
catch
{
try
{
AutoGenQueryProcessing(query);
}
catch (Exception ex)
{
answer = CreateExceptionAnswer(ex, query);
PushAnswerAndDeleteQuery(answer);
}
}
}
break;
case QueryType.SubscribeToEvent:
case QueryType.UnsubscribeFromEvent:
{
object qObj = UsedObjs.Contains(query.ObjectKey) ? UsedObjs[query.ObjectKey] : ServerDictionaries.GetObjectFromTheDictionary(query.ObjectKey);
try
{
System.Reflection.EventInfo ei = qObj.GetType().GetEvent(query.MemberName);
if (EventHandler.EventAppsSubscribersNum.ContainsKey(query.MemberName))
{
EventHandler.EventAppsSubscribersNum[query.MemberName] =
query.QueryType == QueryType.SubscribeToEvent ?
EventHandler.EventAppsSubscribersNum[query.MemberName] + 1 :
EventHandler.EventAppsSubscribersNum[query.MemberName] - 1;
}
else
{
EventHandler.EventAppsSubscribersNum.Add(query.MemberName, 1);
}
// Find corresponding CQG delegate
Type delType = FindDelegateType(CQGAssm, query.MemberName);
// Instantiate the delegate with our own handler
var eventHandlersMethods = typeof(CQGEventHandlers).GetMethods();
MethodInfo handlerInfo = null;
for (int i = 0; i < eventHandlersMethods.Length; i++)
{
if (eventHandlersMethods[i].Name.Contains(query.MemberName))
{
handlerInfo = eventHandlersMethods[i];
}
}
Delegate d = Delegate.CreateDelegate(delType, handlerInfo);
if (query.QueryType == QueryType.SubscribeToEvent)
{
// Subscribe our handler to CQG event
ei.AddEventHandler(qObj, d);
}
else if (query.QueryType == QueryType.UnsubscribeFromEvent)
{
// Unsubscribe our handler from CQG event
ei.RemoveEventHandler(qObj, d);
}
answer = new AnswerInfo(query.QueryKey, query.ObjectKey, query.MemberName, value: true);
PushAnswerAndDeleteQuery(answer);
}
catch
{
try
{
AutoGenQueryProcessing(query);
}
catch (Exception ex)
{
answer = CreateExceptionAnswer(ex, query);
PushAnswerAndDeleteQuery(answer);
}
}
if (query.QueryType == QueryType.SubscribeToEvent &&
query.MemberName == "DataConnectionStatusChanged")
{
// Fire this event explicitly, because data collector connects to real CQG beforehand and does not fire it anymore
CQGEventHandlers._ICQGCELEvents_DataConnectionStatusChangedEventHandlerImpl(CqgDataManagement.currConnStat);
}
}
break;
default:
{
throw new ArgumentOutOfRangeException();
}
}
}
public abstract TEventInfo Create(TTypeInfo declaringType, System.Reflection.EventInfo eventInfo);
public HandlerNotFoundException(string handler_name, string signal_name,
System.Reflection.EventInfo evnt, Type delegate_type)
: this(handler_name, signal_name, evnt, delegate_type, null)
{
}
public override UnrealEventInfo Create(UnrealTypeInfo declaringType, EventInfo eventInfo)
{
return(EventCache.GetOrAdd(eventInfo, e => new UnrealEventInfo(this, declaringType, e)));
}
public static System.Reflection.MethodInfo GetRaiseMethod(this System.Reflection.EventInfo eventInfo)
{
throw null;
}
public static System.Reflection.MethodInfo GetRemoveMethod(this System.Reflection.EventInfo eventInfo, bool nonPublic)
{
throw null;
}
public LocalEventImplementation(System.Reflection.EventInfo eventInfo)
{
this.eventInfo = eventInfo;
this.addMethod = this.eventInfo.GetAddMethod(true);
this.access = (this.addMethod != null ? PlatformTypeHelper.GetMemberAccess(this.addMethod) : MemberAccessType.Private);
}
private void AddEvent(WindowTabInfo tabInfo, object manager, WindowTabEventManagerType type)
{
var list = ADInfoBll.Instance.GetWindowTabEventInfos(tabInfo.Name, type);
foreach (var info in list)
{
System.Reflection.EventInfo eventInfo = manager.GetType().GetEvent(info.EventName);
Type handlerType = eventInfo.EventHandlerType;
//MethodInfo invokeMethod = handlerType.GetMethod("Invoke");
//ParameterInfo[] parms = invokeMethod.GetParameters();
//Type[] parmTypes = new Type[parms.Length];
//for (int i = 0; i < parms.Length; i++)
//{
// parmTypes[i] = parms[i].ParameterType;
//}
//Type dType = Expression.GetActionType(parmTypes);
Delegate d = null;
switch (type)
{
case WindowTabEventManagerType.SearchManager:
switch (info.EventName)
{
case "DataLoaded":
{
EventHandler <DataLoadedEventArgs> d1 = (sender, e) =>
{
EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
};
d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
}
break;
case "DataLoading":
{
EventHandler <DataLoadingEventArgs> d1 = (sender, e) =>
{
EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
};
d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
}
break;
default:
throw new ArgumentException("invalid EventName of " + info.EventName);
}
break;
case WindowTabEventManagerType.DisplayManager:
switch (info.EventName)
{
case "PositionChanging":
{
EventHandler <System.ComponentModel.CancelEventArgs> d1 = (sender, e) =>
{
EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
};
d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
}
break;
case "PositionChanged":
{
EventHandler d1 = (sender, e) =>
{
EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
};
d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
}
break;
case "SelectedDataValueChanged":
{
EventHandler <SelectedDataValueChangedEventArgs> d1 = (sender, e) =>
{
EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
};
d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
}
break;
default:
throw new ArgumentException("invalid EventName of " + info.EventName);
}
break;
case WindowTabEventManagerType.ControlManager:
switch (info.EventName)
{
case "BeginningEdit":
case "EditBegun":
case "EndingEdit":
case "EditEnded":
case "EditCanceled":
case "StateChanged":
{
EventHandler d1 = (sender, e) =>
{
EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
};
d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
}
break;
case "CancellingEdit":
{
EventHandler <System.ComponentModel.CancelEventArgs> d1 = (sender, e) =>
{
EventProcessUtils.ExecuteEventProcess(ADInfoBll.Instance.GetEventProcessInfos(info.EventProcessName), sender, e);
};
d = Delegate.CreateDelegate(handlerType, d1.Target, d1.Method);
}
break;
default:
throw new ArgumentException("invalid EventName of " + info.EventName);
}
break;
case WindowTabEventManagerType.BusinessLayer:
break;
default:
throw new ArgumentException("invalid WindowTabEventManagerType of " + type);
}
if (d != null)
{
eventInfo.AddEventHandler(manager, d);
}
}
}
