public override void OnEntry(MethodExecutionEventArgs eventArgs) { if (eventArgs.Method == somethingOnComponent2) // Pseudo-code { Trace.TraceInformation("Entering {0}.", eventArgs.Method); } }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { if (eventArgs.GetArguments()[position] == null) { throw new ArgumentNullException(name); } }
public override void OnException(MethodExecutionEventArgs eventArgs) { base.OnException(eventArgs); Debug.Assert(false, eventArgs.Exception.Message); eventArgs.ReturnValue = null; eventArgs.FlowBehavior = FlowBehavior.Return; }
/// <summary> /// Raises the <see cref=E:Entry/> event. /// </summary> /// <param name="eventArgs">The <see cref="PostSharp.Laos.MethodExecutionEventArgs"/> instance containing the event data.</param> public override void OnEntry(MethodExecutionEventArgs eventArgs) { now = DateTime.Now; // Console.WriteLine(String.Format("\t\t\tEntered in method {2}/{0} at {1} ", eventArgs.Method.Name, now, eventArgs.Instance != null ? eventArgs.Instance.GetType().Name : "")); RoLog.Instance.LastMessage = OnExceptionMessage; if (RoConfig.Instance.DebugLevel >= debugLevel || debugOnConsole) { string logMessage = prefixes[debugLevel]; logMessage += String.Format("<{0}/{1}/", eventArgs.Instance != null ? eventArgs.Instance.GetType().Name : "Static", eventArgs.Method); if (eventArgs.GetArguments() != null) { foreach (object o in eventArgs.GetArguments()) { logMessage += (o == null ? "NULL|" : o + "|"); } } else { logMessage += "none"; } logMessage += ">"; RoLog.Instance.Add(logMessage); if (debugOnConsole) Console.WriteLine(logMessage); RoLog.Instance.WriteToLog(logMessage, debugLevel); // VRLog.Instance.WriteToLog(logMessage); } }
/// <summary> /// Executed when the set accessor successfully completes. Raises the /// <see cref="INotifyPropertyChanged.PropertyChanged"/> event. /// </summary> /// <param name="eventArgs">Event arguments with information about the /// current execution context.</param> public override void OnSuccess(MethodExecutionEventArgs eventArgs) { if (implementation != null) { implementation.FirePropertyChanged(implementation.instance, new PropertyChangedEventArgs(propertyName)); } }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { if (_conditions[0] == "Bob") { eventArgs.FlowBehavior = FlowBehavior.Return; // return immediately without executing } }
public override void OnSuccess(MethodExecutionEventArgs eventArgs) { var instance = (IComposed <INotifyPropertyChanged>)eventArgs.Instance; var implementation = (NotifyPropertyChangedImplementation)instance.GetImplementation(eventArgs.InstanceCredentials); implementation.OnPropertyChanged(this.propertyName); }
public override void OnExit(MethodExecutionEventArgs eventArgs) { base.OnExit(eventArgs); Trace.Unindent(); Trace.WriteLine("End " + eventArgs.Method.Name); }
public override void OnExit(MethodExecutionEventArgs eventArgs) { string instanceName = eventArgs.Instance == null ? "STATISCHES OBJEKT" : eventArgs.Instance.ToString(); string message = string.Format("Exiting {0} on object {1}", eventArgs.Method, instanceName); this.Log(message); }
public override void OnException(MethodExecutionEventArgs eventArgs) { ExceptionLogger.LogException(eventArgs.Exception, IsSilent, eventArgs.Method.DeclaringType); if (IsSilent) { eventArgs.FlowBehavior = FlowBehavior.Return; eventArgs.ReturnValue = ReturnValue; } }
/// <summary> /// Executed when the set accessor successfully completes. Raises the /// <see cref="INotifyPropertyChanged.PropertyChanged"/> event. /// </summary> /// <param name="eventArgs">Event arguments with information about the /// current execution context.</param> public override void OnSuccess(MethodExecutionEventArgs eventArgs) { implementation = (IFirePropertyChanged) ((IComposed <INotifyPropertyChanged>)eventArgs.Instance).GetImplementation(eventArgs.InstanceCredentials); implementation.OnPropertyChanged(propertyName); // Raises the PropertyChanged event. }
public override bool BeforeExecute(MethodExecutionEventArgs args) { Console.WriteLine("------------------"); Console.WriteLine(args.Instance); Console.WriteLine(args.Method); Console.WriteLine(this.GetType() + ":" + "before execute"); return(true); }
/// <summary> /// Executed when the set accessor successfully completes. Raises the /// <see cref="INotifyPropertyChanged.PropertyChanged"/> event. /// </summary> /// <param name="eventArgs">Event arguments with information about the /// current execution context.</param> public override void OnSuccess(MethodExecutionEventArgs eventArgs) { implementation = (IFirePropertyChanged) ((IComposed<INotifyPropertyChanged>) eventArgs.Instance).GetImplementation(eventArgs.InstanceCredentials); implementation.OnPropertyChanged(propertyName); // Raises the PropertyChanged event. }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { Session session = GetSession(); if (session.IsOn(m_Level)) { session.EnterMethod(Level, FormatEntry(eventArgs)); } }
public override void OnExit(MethodExecutionEventArgs eventArgs) { var sealable = eventArgs.Instance as ISealable; if (sealable != null && sealable.IsSealed) { throw new InvalidOperationException(string.Format("The method '{0}' on type '{1}' could not be invoked because the instance has been marked as sealed.", eventArgs.Method.Name, eventArgs.Method.DeclaringType.Name)); } }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { if (!Proceed(eventArgs)) { return; } Console.WriteLine(GetMethodName(eventArgs)); }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { if (eventArgs.Method.Name.StartsWith("set_")) { ((SearchBagBase)eventArgs.Instance).PropertiesChanged.Add(eventArgs.Method.Name); } base.OnEntry(eventArgs); }
private bool ShouldLog(ILog logger, LoggingLevel loggingLevel, MethodExecutionEventArgs args) { if (args != null && args.Method != null && args.Method.Name != null) { return(logger.IsEnabledFor(loggingLevel)); } return(false); }
public override void OnExit(MethodExecutionEventArgs eventArgs) { if (!Proceed(eventArgs)) { return; } Console.WriteLine(string.Format("{0} returned {1}", GetMethodName(eventArgs), eventArgs.ReturnValue)); }
public override void OnException(MethodExecutionEventArgs eventArgs) { if (!Proceed(eventArgs)) { return; } Console.WriteLine(string.Format("Exception at {0}:\n{1}", GetMethodName(eventArgs), eventArgs.Exception)); }
public override void OnSuccess(MethodExecutionEventArgs eventArgs) { MethodBase fctName = eventArgs.Method; Dictionary<int, bool> fctCache = cache[fctName]; int param = (int)eventArgs.GetReadOnlyArgumentArray()[0]; bool retVal = (bool)eventArgs.ReturnValue; fctCache.Add(param, retVal); }
public override void OnException(MethodExecutionEventArgs eventArgs) { //var exceptionHandler = DIContainer.GetInstance<IExceptionHandler>(); //exceptionHandler.AddMessage(eventArgs.Exception); //exceptionHandler.HandleException(); //eventArgs.FlowBehavior = FlowBehavior.Return; }
public override void OnException(MethodExecutionEventArgs args) { ErrorLoggerUtil.LogException(args.Exception); if (Notify) { MessageBox.Show("An error has occurred. Please save blah blah blah", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } args.FlowBehavior = FlowBehavior.Return; }
public override void OnSuccess(MethodExecutionEventArgs e) { base.OnSuccess(e); if (!ReadOnly && !NeverCommit) scopes.Peek().VoteCommit(); else scopes.Peek().VoteRollBack(); }
public override void OnExit(MethodExecutionEventArgs eventArgs) { Account account = (Account)eventArgs.Instance; Console.WriteLine(string.Format( "Finished {2} transaction on account {0}. Balance after the operation is ${1}.", account.Number, account.CurrentBalance, eventArgs.Method.Name)); }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { InputDialog dlg = new InputDialog(); if (dlg.ShowDialog() != System.Windows.Forms.DialogResult.OK) return; ElementEventArgs ea = new ElementEventArgs(); ea.Element = dlg.Input; Controller.InvokeSomethingCreated(this, ea); }
public override void OnException(MethodExecutionEventArgs eventArgs) { string instanceName = eventArgs.Instance == null ? "STATISCHES OBJEKT" : eventArgs.Instance.ToString(); string message = string.Format("Exception {0} on object {1}", eventArgs.Method, instanceName) + Environment.NewLine; message = message.Space(4).Append(eventArgs.Exception.Message); this.Log(message); eventArgs.FlowBehavior = FlowBehavior.Continue; }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { //save old value in order to check if setter actually changes value, only fire OnSetter if it does change if (prop == null) prop = eventArgs.Instance.GetType().GetProperty(eventArgs.Method.Name.Replace("set_", "")); if (prop != null) { object oldobj = prop.GetValue(eventArgs.Instance, null); if (oldobj != null) oldVal = oldobj.ToString(); } }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { // Get out fast if tracing is disabled _tracingEnabled = Enabled; if (!_tracingEnabled) return; _stopwatch.Reset(); _stopwatch.Start(); }
public override void OnException(MethodExecutionEventArgs eventArgs) { Exception e = eventArgs.Exception; if (e != null) { Session session = GetSession(); session.LogException(FormatException(e), e); } }
/// <summary> /// Executed when the set accessor successfully completes. Raises the /// <see cref="INotifyPropertyChanged.PropertyChanged"/> event. /// </summary> /// <param name="eventArgs">Event arguments with information about the /// current execution context.</param> public override void OnSuccess(MethodExecutionEventArgs eventArgs) { // Get the implementation of INotifyPropertyChanged. We have access to it through the IComposed interface, // which is implemented at compile time. IFirePropertyChanged fireSemantic = ((IProtectedInterface <IFirePropertyChanged>)eventArgs.Instance).GetInterface(eventArgs.InstanceCredentials); // Raises the PropertyChanged event. fireSemantic.FirePropertyChanged(propertyName); }
public override void OnException(MethodExecutionEventArgs eventArgs) { // Compose the error message. We could do something more complex. string message = eventArgs.Exception.Message; MessageBoxHelper.Display(eventArgs.Instance as DependencyObject, message); // Ignore the exception. eventArgs.FlowBehavior = FlowBehavior.Continue; }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { //ignore call from reflection if (eventArgs.GetReadOnlyArgumentArray() != null) { //check for null if (eventArgs.GetReadOnlyArgumentArray()[0] == null) throw new ValidationException("Value was null.", eventArgs); } base.OnEntry(eventArgs); }
//event bubbling public override void OnEntry(MethodExecutionEventArgs eventArgs) { PropertyInfo pi = eventArgs.Instance.GetType().GetProperty(propertyName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); oldValue = pi.GetValue(eventArgs.Instance, null); newValue = eventArgs.GetReadOnlyArgumentArray()[0]; // will work only for simple properties! base.OnEntry(eventArgs); }
public override void OnSuccess(MethodExecutionEventArgs eventArgs) { if (prop != null) { object newobj = prop.GetValue(eventArgs.Instance, null); if ((newobj == null && !String.IsNullOrEmpty(oldVal)) || (newobj != null && newobj.ToString() != oldVal)) { eventArgs.Instance.GetType().InvokeMember(_OnSetterMethodName, BindingFlags.InvokeMethod, null, eventArgs.Instance, new object[] { prop.Name }); } } }
public override void OnSuccess(MethodExecutionEventArgs eventArgs) { if (transaction != null) { ((SQLiteTransaction) transaction).Commit(); } if (DB.Connection.State == ConnectionState.Open) { DB.Connection.Close(); } }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { if (eventArgs.GetReadOnlyArgumentArray() != null) { string value = (string)eventArgs.GetReadOnlyArgumentArray()[0]; if (Regex.IsMatch(value, RegularExpression) != this.MustMatch) throw new ValidationException("Value did not match the specified regular expression [" + RegularExpression + "]", eventArgs); } base.OnEntry(eventArgs); }
protected override object CloseUnitOfWork(MethodExecutionEventArgs eventArgs) { object transactionState = base.CloseUnitOfWork(eventArgs); if (TransactionManager.TransactionDepth == 0) { var sessionStorage = (NHibernateSession.Storage as IUnitOfWorkSessionStorage); if (sessionStorage != null) { sessionStorage.EndUnitOfWork(CloseSessions); } } return transactionState; }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { _logger = LogManager.GetLogger(eventArgs.Method.DeclaringType.ToString()); if (ShowParameters = true) { _logger.DebugFormat("Entered {0} with args:{1}", eventArgs.Method.Name, args); } else { _logger.DebugFormat("Entered {0}", eventArgs.Method.Name); } }
/// <summary/> public override void OnEntry(MethodExecutionEventArgs eventArgs) { bool isSecureConnection = HttpContext.Current.Request.IsSecureConnection; if(!isSecureConnection) { bool secureConnectionIsRequired; if(!bool.TryParse(ConfigurationManager.AppSettings[appSettingsDisableKey], out secureConnectionIsRequired) || secureConnectionIsRequired) { throw new SecurityException("A secure connection is required to call this method."); } } }
public override void OnException(MethodExecutionEventArgs eventArgs) { eventArgs.InstanceTag = CloseUnitOfWork(eventArgs); if (!(eventArgs.Exception is AbortTransactionException)) { ExceptionLogger.LogException(eventArgs.Exception, IsExceptionSilent, eventArgs.Method.DeclaringType); } if (TransactionManager.TransactionDepth == 0 && (IsExceptionSilent || eventArgs.Exception is AbortTransactionException)) { eventArgs.FlowBehavior = FlowBehavior.Return; eventArgs.ReturnValue = ReturnValue; } }
public override void OnException(MethodExecutionEventArgs eventArgs) { if(eventArgs.Exception.GetType() == typeof(FrameNotFoundException)) { log.Debug(eventArgs.Exception.StackTrace); //eventArgs.Method.Invoke() //Framework.CallTrace("Relogging"); } string message = eventArgs.Exception.Message; eventArgs.FlowBehavior = FlowBehavior.Continue; }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { var arguments = eventArgs.GetReadOnlyArgumentArray(); for (var i = 0; i < arguments.Length; ++i) { var argumentValue = arguments[i]; var parameterRules = _parameterRules[i]; foreach (var rule in parameterRules.RulesToApply) { rule.ValidateParameter(parameterRules.Parameter, argumentValue); } } }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { if (eventArgs.Instance == null) throw new InvalidOperationException("Cannot decorate UpdateForm on static classes"); if (!(eventArgs.Instance is Form)) throw new InvalidOperationException("UpdateForm requires a Form to operate"); object sender = eventArgs.GetReadOnlyArgumentArray()[0]; ElementEventArgs ea = (ElementEventArgs)eventArgs.GetReadOnlyArgumentArray()[1]; Form frm = (Form)eventArgs.Instance; frm.Text = ea.Element + " -said by " + sender; }
protected override object CloseUnitOfWork(MethodExecutionEventArgs eventArgs) { object transactionState = base.CloseUnitOfWork(eventArgs); if (TransactionManager.TransactionDepth == 0) { var sessionStorage = (NHibernateSession.Storage as IUnitOfWorkSessionStorage); if (sessionStorage != null) { sessionStorage.EndUnitOfWork(CloseSessions); } } return(transactionState); }
public override void OnExit(MethodExecutionEventArgs eventArgs) { DateTime end = DateTime.Now; DateTime start = (DateTime)eventArgs.MethodExecutionTag; TimeSpan duration = end - start; if (duration.TotalMilliseconds >= Threshold) { Trace.WriteLine( String.Format("{2} ms took execution of {0}.{1}.", eventArgs.Method.DeclaringType.FullName, eventArgs.Method.Name, (end - start).TotalMilliseconds)); } }
public override void OnEntry(MethodExecutionEventArgs e) { base.OnEntry(e); if (scopes == null) scopes = new Stack<ITransactionManager>(); TransactionModeEnum transactionMode = IsNew || ReadOnly ? TransactionModeEnum.New : TransactionModeEnum.Inherits; var transactionManager = new TransactionManagerFluent(); transactionManager.Initialize(); scopes.Push(transactionManager); }
public override void OnException(MethodExecutionEventArgs eventArgs) { Console.WriteLine(eventArgs.Method.DeclaringType.Name); Console.WriteLine(eventArgs.Method.Name); Console.WriteLine(eventArgs.Exception.StackTrace); ParameterInfo[] parameterInfos = eventArgs.Method.GetParameters(); object[] paramValues = eventArgs.GetReadOnlyArgumentArray(); for (int i = 0; i < parameterInfos.Length; i++) { Console.WriteLine(parameterInfos[i].Name + "=" + paramValues[i]); } eventArgs.FlowBehavior = FlowBehavior.Default; }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { string SQL = string.Format(@"Insert into SysLog (ModelName,LogContent,LogTime) values (@ModelName,@LogContent,@LogTime)"); SqlParameter[] parms = { new SqlParameter("@ModelName", ModelName), new SqlParameter("@LogContent", string.IsNullOrEmpty(LogContent) ? ModelName + "执行了操作。" : LogContent), new SqlParameter("@LogTime", DateTime.Now)}; SqlHelper.ExecuteSql(SQL, parms); base.OnEntry(eventArgs); // eventArgs.FlowBehavior = FlowBehavior.Return; // eventArgs.ReturnValue = false; }
/// <summary> /// Method executed <b>after</b> the body of methods /// to which this aspect is applied, when the method ends with an exception. /// </summary> /// <param name="eventArgs">Event arguments specifying which method /// is being executed and which are its arguments.</param> public override void OnException(MethodExecutionEventArgs eventArgs) { #if !MONO //Trace.Unindent(); #endif Trace.TraceWarning( this.prefix + "Leaving " + this.formatStrings.Format( eventArgs.Instance, eventArgs.Method, eventArgs.GetReadOnlyArgumentArray() ) + Formatter.FormatString(" with exception {0} : {{{1}}}.", eventArgs.Exception.GetType().Name, eventArgs.Exception.Message)); }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { //save old value in order to check if setter actually changes value, only fire OnSetter if it does change if (prop == null) { prop = eventArgs.Instance.GetType().GetProperty(eventArgs.Method.Name.Replace("set_", "")); } if (prop != null) { object oldobj = prop.GetValue(eventArgs.Instance, null); if (oldobj != null) { oldVal = oldobj.ToString(); } } }
public override void OnException(MethodExecutionEventArgs eventArgs) { if (transaction != null) { try { ((SQLiteTransaction) transaction).Rollback(); } catch (Exception) {} } if (DB.Connection.State == ConnectionState.Open) { DB.Connection.Close(); } }
/// <summary> /// Method executed <b>after</b> the body of methods /// to which this aspect is applied, when the method succeeds. /// </summary> /// <param name="eventArgs">Event arguments specifying which method /// is being executed and which are its arguments.</param> public override void OnSuccess(MethodExecutionEventArgs eventArgs) { //if (this.prefix.Length > 0) // this.prefix = this.prefix.Substring(0, this.prefix.Length - 1); //Trace.Write("< " + this.prefix + eventArgs.Instance + " - " + eventArgs.Method); //Trace.Write("< " + this.prefix + eventArgs.Method.DeclaringType.FullName + " - " + eventArgs.Method); //return; //Trace.TraceInformation( Trace.Write( this.prefix + "< Leaving " + this.formatStrings.Format( eventArgs.Instance, eventArgs.Method, eventArgs.GetReadOnlyArgumentArray()) + (this.isVoid ? "" : Formatter.FormatString(" : {{{0}}}.", eventArgs.ReturnValue))); }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { // Get the graph instance associated with the current object GraphInstance instance = ((IGraphInstance)eventArgs.Instance).Instance; // Exit immediately if the property is not valid for the current graph type if (!instance.Type.Properties.Contains(property)) { return; } // Store the current property value as a method execution tag eventArgs.MethodExecutionTag = instance[this.property]; // Call the base class implementation base.OnEntry(eventArgs); }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { // create fct dict if not exists if (!cache.ContainsKey(eventArgs.Method)) cache.Add(eventArgs.Method, new Dictionary<int, bool>()); // get fct-dict and fct-parameter Dictionary<int, bool> fctCache = cache[eventArgs.Method]; int param = (int)eventArgs.GetReadOnlyArgumentArray()[0]; // lookup calculated result if (fctCache.ContainsKey(param)) { eventArgs.ReturnValue = fctCache[param]; eventArgs.FlowBehavior = FlowBehavior.Return; } }
public override void OnEntry(MethodExecutionEventArgs eventArgs) { /* * if (implementation == null) * { */ implementation = (NotifyPropertyChangeImplementation) ((IComposed <INotifyPropertyChange>)eventArgs.Instance).GetImplementation( eventArgs.InstanceCredentials); /* * } */ implementation.FirePropertyChanging(implementation.instance, new PropertyChangingEventArgs(propertyName)); }