/// <summary> /// Method invoked when (instead of) a new handler is added to the target event. /// </summary> /// <param name="args">Context information.</param> public override void OnAddHandler(EventInterceptionArgs args) { var weakEventClient = args.Handler.Target as IWeakEventClient; bool supportsWeakReference = weakEventClient != null; // Throw an exception if the client does not support weak events and we are not allowed to hold strong references. if (!supportsWeakReference && args.Handler.Target != null && !AllowStrongReferences) { throw new InvalidOperationException( $"Attempt to add a reference to the weak event {args.Event} from type {args.Handler.Target.GetType()}, which does not implement the IWeakEventClient interface."); } // Add the handler to our own list. if (_weakEventHandler.AddHandler(args.Handler, supportsWeakReference)) { // If it is the first handler we are adding, add a fake handler to ourselves to the target event. // Whichever handler will add here will be passed to OnInvokeHandler, so it is safe and convenient to pass null. args.AddHandler(null); } // Register the handler to the client to prevent garbage collection of the handler. if (supportsWeakReference) { weakEventClient.RegisterEventHandler(args.Handler); } }
/// <summary> /// Method invoked <i>instead</i> of the <c>Remove</c> semantic of the event to which the current aspect is applied, /// i.e. when a delegate is removed from this event. /// </summary> /// <param name="args">Handler arguments.</param> public override void OnRemoveHandler(EventInterceptionArgs args) { Console.WriteLine(string.Format("Event {0} removed.", args.Event.Name)); //If ProceedRemoveHandler is not called the handler that //was supposed to be removed will never get removed. args.ProceedRemoveHandler(); }
public override void OnRemoveHandler(EventInterceptionArgs args) { StringBuilder sb = new StringBuilder(); sb.AppendFormat("Event {0} was removed from\n", args.Event.Name); sb.AppendFormat("\tclass: {0} \n", args.Handler.Target.GetType().FullName); sb.AppendFormat("\tassembly: {0}", args.Handler.Target.GetType().Module); Console.WriteLine(sb); base.OnRemoveHandler(args); }
public override void OnInvokeHandler(EventInterceptionArgs args) { int x = 0; if (x > 0) //Do you logic here { args.ProceedInvokeHandler(); } }
public override void OnAddHandler(EventInterceptionArgs args) { lock (_lockObject) { if (!_delegates.Contains(args.Handler)) { _delegates.Add(args.Handler); args.ProceedAddHandler(); } } }
public override void OnRemoveHandler(EventInterceptionArgs args) { lock (_lockObject) { if (_delegates.Contains(args.Handler)) { _delegates.Remove(args.Handler); args.ProceedRemoveHandler(); } } }
/// <summary> /// Method invoked when (instead of) a new handler is removed from the target event. /// </summary> /// <param name="args">Context information.</param> public override void OnRemoveHandler(EventInterceptionArgs args) { // Remove the handler from our own list. if (RemoveHandler(args.Handler)) { args.RemoveHandler(null); } // Remove the handler from the client. DelegateReferenceKeeper.RemoveReference(args.Handler); }
/// <summary> /// Method invoked when (instead of) a new handler is removed from the target event. /// </summary> /// <param name="args">Context information.</param> public override void OnRemoveHandler(EventInterceptionArgs args) { // Remove the handler from our own list. if (RemoveHandler(args.Handler)) { // If this is the last handler, remove the fake handler to ourselves from the target event. args.RemoveHandler(null); } // Remove the handler from the client. DelegateReferenceKeeper.RemoveReference(args.Handler); }
private static void Invoke(EventInterceptionArgs args) { try { args.ProceedInvokeHandler(); } catch (Exception e) { Trace.TraceError(e.ToString()); args.ProceedRemoveHandler(); } }
/// <summary> /// Method invoked when (instead of) a new handler is added to the target event. /// </summary> /// <param name="args">Context information.</param> public override void OnAddHandler(EventInterceptionArgs args) { // Add the handler to our own list. if (AddHandler(args.Handler)) { args.AddHandler(null); } // Register the handler to the client to prevent garbage collection of the handler. DelegateReferenceKeeper.AddReference(args.Handler); }
public override void OnInvokeHandler(EventInterceptionArgs args) { ThreadPool.QueueUserWorkItem(state => { try { args.ProceedInvokeHandler(); } catch { args.ProceedRemoveHandler(); } }); }
/// <summary> /// Method invoked when (instead of) a new handler is added to the target event. /// </summary> /// <param name="args">Context information.</param> public override void OnAddHandler(EventInterceptionArgs args) { // Add the handler to our own list. if (AddHandler(args.Handler)) { // If it is the first handler we are adding, add a fake handler to ourselves to the target event. // Whichever handler will add here will be passed to OnInvokeHandler, so it is safe and convenient to pass null. args.AddHandler(null); } // Register the handler to the client to prevent garbage collection of the handler. DelegateReferenceKeeper.AddReference(args.Handler); }
public override void OnInvokeHandler( EventInterceptionArgs args ) { ThreadPool.QueueUserWorkItem( state => { try { args.ProceedInvokeHandler(); } catch { args.ProceedRemoveHandler(); } } ); }
public override void OnInvokeHandler(EventInterceptionArgs args) { DispatcherObject dispatcherObject = args.Handler.Target as DispatcherObject; if (dispatcherObject == null || dispatcherObject.CheckAccess()) { args.ProceedInvokeHandler(); } else { // We have to dispatch synchronously to avoid the object to be changed // before the time the event is raised and the time it is processed. dispatcherObject.Dispatcher.Invoke(DispatcherPriority.Normal, new Action(args.ProceedInvokeHandler)); } }
public override void OnInvokeHandler( EventInterceptionArgs args ) { DispatcherObject dispatcherObject = args.Handler.Target as DispatcherObject; if ( dispatcherObject == null || dispatcherObject.CheckAccess() ) { args.ProceedInvokeHandler(); } else { // We have to dispatch synchronously to avoid the object to be changed // before the time the event is raised and the time it is processed. dispatcherObject.Dispatcher.Invoke( DispatcherPriority.Normal, new Action( args.ProceedInvokeHandler ) ); } }
public void OnInvoke(EventInterceptionArgs args) { ReaderWriterLockSlim @lock = ((IReaderWriterSynchronized)args.Instance).Lock; bool reEnterWriteLock = @lock.IsWriteLockHeld; this.Enter(@lock); try { args.ProceedInvokeHandler(); } finally { this.Exit(reEnterWriteLock, @lock); } }
/// <summary> /// Method invoked when (instead of) a new handler is removed from the target event. /// </summary> /// <param name="args">Context information.</param> public override void OnRemoveHandler(EventInterceptionArgs args) { var weakEventClient = args.Handler.Target as IWeakEventClient; bool supportsWeakReference = weakEventClient != null; // Remove the handler from our own list. if (_weakEventHandler.RemoveHandler(args.Handler)) { // If this is the last handler, remove the fake handler to ourselves from the target event. args.RemoveHandler(null); } // Remove the handler from the client. if (supportsWeakReference) { weakEventClient.UnregisterEventHandler(args.Handler); } }
/// <summary> /// Method invoked when the event to which the current aspect is applied is fired, <i>for each</i> delegate /// of this event, and <i>instead of</i> invoking this delegate. /// </summary> /// <param name="args">Handler arguments.</param> /// <exception cref="System.ArgumentException"> /// 必须为IdentityObject或其子类 /// or /// EventName事件上找不到EventDescriptionAttribute /// </exception> public override void OnInvokeHandler(EventInterceptionArgs args) { base.OnInvokeHandler(args); var i = args.Instance as IdentityObject; if (i == null) { throw new ArgumentException("必须为IdentityObject或其子类"); } var d = args.Event.GetCustomAttribute(typeof(DescriptionAttribute), true) as DescriptionAttribute; if (d == null) { throw new ArgumentException("EventName事件上找不到DescriptionAttribute"); } i.Info("引发" + d.Description); }
internal static void SaveEventInfo(EventInterceptionArgs args, LoggingType loggingType) { try { LogItem item = LogSessionManager.Instance.CurrentSession.GetNewLogItem(); item.HashCode = -1; if (args.Instance != null) { bool firstTime; item.ObjectId = ObjIDGenerator.Instance.GetId(args.Instance, out firstTime); } item.ThreadId = System.Threading.Thread.CurrentThread.ManagedThreadId; item.ProcessId = System.Diagnostics.Process.GetCurrentProcess().Id; item.Name = args.Event.Name; Debug.Assert(args.Event.DeclaringType != null, "args.Event.DeclaringType != null"); item.ClassName = args.Event.DeclaringType.Name; item.Namespace = args.Event.DeclaringType.Namespace; item.LoggingType = loggingType; try { var stackFrame = new StackFrame(3); item.ParentMethod = stackFrame.GetMethod().Name; item.ParentClass = stackFrame.GetMethod().DeclaringType.Name; item.ParentNamespace = stackFrame.GetMethod().DeclaringType.Namespace; } catch { } Database.Instance.Add(item); } catch (Exception ex) { SimpleLogger.Logger.Log("SaveCallInfo", ex); throw; } }
public override void OnInvokeHandler(EventInterceptionArgs args) { Console.WriteLine("Event {0} invoked", args.Event.Name); args.ProceedInvokeHandler(); }
/// <summary> /// Method invoked when (instead of) a the target event is raised. /// </summary> /// <param name="args">Context information.</param> public override void OnInvokeHandler(EventInterceptionArgs args) { // Note that args.Handler == null because it's the value we added in OnAddHandler, but it really does not matter. InvokeHandler(args.Arguments.ToArray()); }
public override void OnAddHandler(EventInterceptionArgs args) { Console.WriteLine("Event eklendi"); args.ProceedAddHandler(); }
public override void OnRemoveHandler(EventInterceptionArgs args) { Console.WriteLine("Event kaldırıldı"); args.ProceedRemoveHandler(); }
public override void OnInvokeHandler(EventInterceptionArgs args) // Вызываем событие асинхронно { Task.Factory.StartNew(() => Invoke(args)).Start(); }
public override void OnInvokeHandler(EventInterceptionArgs args) { Console.WriteLine("Event Invoke Edildi"); args.ProceedInvokeHandler(); }
public override void OnInvokeHandler(EventInterceptionArgs args) { LogHelper.SaveEventInfo(args, LogHelper.LoggingType.EventRaised); base.OnInvokeHandler(args); }
public void OnInvoke( EventInterceptionArgs args ) { ReaderWriterLockSlim @lock = ((IReaderWriterSynchronized)args.Instance).Lock; bool reEnterWriteLock = @lock.IsWriteLockHeld; this.Enter( @lock ); try { args.ProceedInvokeHandler(); } finally { this.Exit( reEnterWriteLock, @lock ); } }
public override void OnAddHandler(EventInterceptionArgs args) { Console.WriteLine("Event {0} added", args.Event.Name); args.ProceedAddHandler(); }