public override void OnSetValue(FieldAccessEventArgs eventArgs) { int i = (int?)eventArgs.InstanceTag ?? 0; eventArgs.InstanceTag = i + 1; Console.WriteLine("value set!"); base.OnSetValue(eventArgs); }
public override void OnGetValue(FieldAccessEventArgs eventArgs) { Console.WriteLine("Get {0} {1} exposed={2} stored={3}", eventArgs.DeclaringType, eventArgs.FieldInfo, eventArgs.ExposedFieldValue, eventArgs.StoredFieldValue); if (!_values.ContainsKey(eventArgs.FieldInfo)) { _values[eventArgs.FieldInfo] = eventArgs.StoredFieldValue; } eventArgs.ExposedFieldValue = _values[eventArgs.FieldInfo]; }
private void HandleFieldAccess(object sender, FieldAccessEventArgs e) { if (e.SuspendPolicy == SuspendPolicy.All) { Interlocked.Increment(ref _suspended); } throw new NotImplementedException(); }
public override void OnGetValue(FieldAccessEventArgs eventArgs) { Console.WriteLine("Get {0} {1} exposed={2} stored={3}", eventArgs.DeclaringType, eventArgs.FieldInfo, eventArgs.ExposedFieldValue, eventArgs.StoredFieldValue); if (!_values.ContainsKey(eventArgs.FieldInfo)) { _values[eventArgs.FieldInfo] = eventArgs.StoredFieldValue; } eventArgs.ExposedFieldValue = _values[eventArgs.FieldInfo]; }
public override void OnSetValue(FieldAccessEventArgs eventArgs) { IFirePropertyChanged implementation = (IFirePropertyChanged) ((IComposed <INotifyPropertyChanged>)eventArgs.Instance).GetImplementation(eventArgs.InstanceCredentials); //// no bubbling (performance)! // next optimization does not work; run unit tests //if (implementation.ObserversObjects.Count == 0) //{ // base.OnSetValue(eventArgs); // return; //} object oldValue = eventArgs.StoredFieldValue; object newValue = eventArgs.ExposedFieldValue; // manage subscription to childobjects that are notifiable if (oldValue is INotifyPropertyChanged) { implementation.Unsubscribe(oldValue as INotifyPropertyChanged); } if (newValue is INotifyPropertyChanged) { implementation.Subscribe(newValue as INotifyPropertyChanged); } /* * base.OnSetValue(eventArgs); */ var value = oldValue ?? newValue; if (value == null) { base.OnSetValue(eventArgs); } else { // prevent calling set values two times, call it only in the last aspect var valueImplements2Aspects = value is INotifyPropertyChanged && value is INotifyCollectionChanged; if (!valueImplements2Aspects || implementation.IsLastPropertyNotifier) { base.OnSetValue(eventArgs); } } }
public override void OnSetValue(FieldAccessEventArgs eventArgs) { IFirePropertyChanged implementation = (IFirePropertyChanged) ((IComposed<INotifyPropertyChanged>) eventArgs.Instance).GetImplementation(eventArgs.InstanceCredentials); //// no bubbling (performance)! // next optimization does not work; run unit tests //if (implementation.ObserversObjects.Count == 0) //{ // base.OnSetValue(eventArgs); // return; //} object oldValue = eventArgs.StoredFieldValue; object newValue = eventArgs.ExposedFieldValue; // manage subscription to childobjects that are notifiable if (oldValue is INotifyPropertyChanged) { implementation.Unsubscribe(oldValue as INotifyPropertyChanged); } if (newValue is INotifyPropertyChanged) { implementation.Subscribe(newValue as INotifyPropertyChanged); } /* base.OnSetValue(eventArgs); */ var value = oldValue ?? newValue; if (value == null) { base.OnSetValue(eventArgs); } else { // prevent calling set values two times, call it only in the last aspect var valueImplements2Aspects = value is INotifyPropertyChanged && value is INotifyCollectionChanged; if (!valueImplements2Aspects || implementation.IsLastPropertyNotifier) { base.OnSetValue(eventArgs); } } }
public override void OnSetValue(FieldAccessEventArgs eventArgs) { var implementation = (IFireCollectionChanged) ((IComposed <INotifyCollectionChanged>)eventArgs.Instance).GetImplementation( eventArgs.InstanceCredentials); var oldValue = eventArgs.StoredFieldValue; var newValue = eventArgs.ExposedFieldValue; // manage subscription to childobjects that are notifiable if (oldValue is INotifyCollectionChanged) { implementation.Unsubscribe(oldValue as INotifyCollectionChanged); } if (newValue is INotifyCollectionChanged) { implementation.Subscribe(newValue as INotifyCollectionChanged); } //base.OnSetValue(eventArgs); var value = oldValue ?? newValue; if (value == null) { base.OnSetValue(eventArgs); } else { if (!thisTypeIsLastComposedType.ContainsKey(eventArgs.DeclaringType)) { var composedBaseTypes = eventArgs.DeclaringType.GetInterfaces() .Where(t => t.Name.Contains("IComposed") && t.IsGenericType); thisTypeIsLastComposedType[eventArgs.DeclaringType] = typeof(IComposed <INotifyCollectionChanged>) == composedBaseTypes.Last(); } // prevent calling set values two times, call it only in the last aspect var valueImplements2Aspects = value is INotifyPropertyChanged && value is INotifyCollectionChanged; if (!valueImplements2Aspects || thisTypeIsLastComposedType[eventArgs.DeclaringType]) { base.OnSetValue(eventArgs); } } }
public override void OnSetValue(FieldAccessEventArgs eventArgs) { var implementation = (IFirePropertyChange) ((IComposed <INotifyPropertyChange>)eventArgs.Instance).GetImplementation(eventArgs.InstanceCredentials); var oldValue = eventArgs.StoredFieldValue; var newValue = eventArgs.ExposedFieldValue; // manage subscription to childobjects that are notifiable if (oldValue is INotifyPropertyChange) { implementation.Unsubscribe(oldValue as INotifyPropertyChange); } if (newValue is INotifyPropertyChange) { implementation.Subscribe(newValue as INotifyPropertyChange); } var value = oldValue ?? newValue; if (value == null) { base.OnSetValue(eventArgs); } else { // prevent calling set values two times, call it only in the last aspect var valueImplements2Aspects = value is INotifyPropertyChange && value is INotifyCollectionChange; if (!valueImplements2Aspects || implementation.IsLastPropertyNotifier) { base.OnSetValue(eventArgs); } } }
public override void OnSetValue(FieldAccessEventArgs eventArgs) { log.Info(eventArgs.FieldInfo.Name.Replace("_", "") + ", changed to: " + eventArgs.ExposedFieldValue.ToString()); base.OnSetValue(eventArgs); }
public override void OnSetValue(FieldAccessEventArgs eventArgs) { Console.WriteLine("Set {0} {1} exposed={2} stored={3}", eventArgs.DeclaringType, eventArgs.FieldInfo, eventArgs.ExposedFieldValue, eventArgs.StoredFieldValue); _values[eventArgs.FieldInfo] = eventArgs.ExposedFieldValue; }
public override void OnSetValue(FieldAccessEventArgs eventArgs) { var implementation = (IFireCollectionChanged) ((IComposed<INotifyCollectionChanged>) eventArgs.Instance).GetImplementation( eventArgs.InstanceCredentials); var oldValue = eventArgs.StoredFieldValue; var newValue = eventArgs.ExposedFieldValue; // manage subscription to childobjects that are notifiable if (oldValue is INotifyCollectionChanged) { implementation.Unsubscribe(oldValue as INotifyCollectionChanged); } if (newValue is INotifyCollectionChanged) { implementation.Subscribe(newValue as INotifyCollectionChanged); } //base.OnSetValue(eventArgs); var value = oldValue ?? newValue; if (value == null) { base.OnSetValue(eventArgs); } else { if (!thisTypeIsLastComposedType.ContainsKey(eventArgs.DeclaringType)) { var composedBaseTypes = eventArgs.DeclaringType.GetInterfaces() .Where(t => t.Name.Contains("IComposed") && t.IsGenericType); thisTypeIsLastComposedType[eventArgs.DeclaringType] = typeof (IComposed<INotifyCollectionChanged>) == composedBaseTypes.Last(); } // prevent calling set values two times, call it only in the last aspect var valueImplements2Aspects = value is INotifyPropertyChanged && value is INotifyCollectionChanged; if (!valueImplements2Aspects || thisTypeIsLastComposedType[eventArgs.DeclaringType]) { base.OnSetValue(eventArgs); } } }
/// <summary> /// Method called instead of the <i>set</i> operation on the modified field. /// We just write a record to the trace subsystem and set the field value. /// </summary> /// <param name="context">Event arguments specifying which field is being /// accessed and which is its current value, and allowing to change its value. /// </param> public override void OnSetValue(FieldAccessEventArgs context) { // Get out fast if tracing is disabled if (!Enabled) return; if ((context.StoredFieldValue == null && context.ExposedFieldValue == null) || (context.StoredFieldValue == null || !context.StoredFieldValue.Equals(context.ExposedFieldValue))) { string caption = FormatString(_setFormatString, context.ExposedFieldValue ?? "<null>", context.Instance); string description = "was: " + context.StoredFieldValue ?? "<null>"; Log.Write(LogMessageSeverity.Verbose, "PostSharp", this, null, null, LogWriteMode.Queued, null, "PostSharp.Set", GAspectBase.Indent(caption), description); } base.OnSetValue(context); }
public override void OnSetValue(FieldAccessEventArgs eventArgs) { Session session = GetSession(); bool isOn = session.IsOn(m_Level) && (m_Log || m_Watch); if (isOn) { string name = FormatName(m_Name, eventArgs.Instance); string newValue = FormatValue(eventArgs.ExposedFieldValue); string oldValue = FormatValue(eventArgs.StoredFieldValue); if (Log) { string message = FormatMessage(name, newValue, oldValue); session.SendCustomLogEntry(message, LogEntryType.VariableValue, ViewerId.Title, null); } if (Watch) { session.SendCustomWatch(m_Level, name, newValue, m_WatchType); } } base.OnSetValue(eventArgs); }
public override void OnSetValue(FieldAccessEventArgs eventArgs) { Console.WriteLine("Set {0} {1} exposed={2} stored={3}", eventArgs.DeclaringType, eventArgs.FieldInfo, eventArgs.ExposedFieldValue, eventArgs.StoredFieldValue); _values[eventArgs.FieldInfo] = eventArgs.ExposedFieldValue; }
public override void OnGetValue(FieldAccessEventArgs eventArgs) { Console.WriteLine(eventArgs.InstanceTag); Console.WriteLine("got value!"); base.OnGetValue(eventArgs); }
/// <summary> /// Methode wird aufgerufen wenn es ein Schreibzugriff auf ein Feld gibt. /// </summary> /// <param name="eventArgs">FieldAccessEventArgs für das Feld auf das ein Schreibzugriff ausgeführt wird.</param> public override void OnSetValue(FieldAccessEventArgs eventArgs) { Initialize(eventArgs.FieldInfo.DeclaringType.Assembly); if (mFieldModel.DbcAccessType == AccessType.OnlyOnGet) { base.OnSetValue(eventArgs); return; } // Die Typen die zur Designzeit als generisch geladen wurden müssen // zur Laufzeit als konkrete Typen definiert werden. Diese konktreten // Typen laden. Es müssen die Typen immer geladen werden, da es sonst // bei verschiedene instanzierungen um verschiedene Typen handeln kann. if ((!mFieldModel.GenericTypesLoaded) && (!eventArgs.Instance.GetType().IsGenericType)) mFieldModel.GenericTypesLoaded = true; if (!mFieldModel.GenericTypesLoaded) mFieldModel.GenericClassTypes = eventArgs.Instance.GetType().GetGenericArguments(); // Wenn das IContract Objekt noch nicht geladen wurde bitte laden if (mFieldModel.ContractObject == null) mFieldModel.ContractObject = ContractController.Instance.GetContractObject(mFieldModel.ContractClassName); // Speichern der Werte die in das Feld geschrieben wurden. object[] fieldValue = new object[] { eventArgs.ExposedFieldValue }; // Kontraktprüfung mFieldModel.ContractObject.CheckContract( mFieldModel.SetContract.ContractKey, fieldValue, eventArgs.Instance, eventArgs.StoredFieldValue, mFieldModel.GenericClassTypes, null); base.OnSetValue(eventArgs); }