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 OnException(MethodExecutionEventArgs eventArgs)
{
ExceptionLogger.LogException(eventArgs.Exception, IsSilent, eventArgs.Method.DeclaringType);
if (IsSilent)
{
eventArgs.FlowBehavior = FlowBehavior.Return;
eventArgs.ReturnValue = ReturnValue;
}
}
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 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 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 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 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 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 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));
}
