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);
}
