public override void OnSetValue(LocationInterceptionArgs args)
{
var holder = (MauComponent)args.Instance;
MauPropertyHolder mauPropHolder = holder.GetMauPropHolder(PropertyName);
object curValue = args.GetCurrentValue();
// Mark this property as it's changed by .Net
mauPropHolder.Touched = true;
// Set value first, so i can reflect it
base.OnSetValue(args);
// Todo: make that 'callBackMethod' an global var
mauPropHolder.SetCallBackMethod ??= holder.GetType().GetMethod($"{args.LocationName}OnSet", BindingFlags.NonPublic | BindingFlags.Static);
if (mauPropHolder.SetCallBackMethod != null && args.Value?.Equals(curValue) == false)
{
mauPropHolder.SetCallBackMethod.Invoke(null, new object[] { holder });
}
// HandleOnSet .?
if (!mauPropHolder.HandleOnSet)
{
return;
}
// if it's set from angular side then will not hit this part
// because of 'HandleOnSet' will be 'false'
if (PropStatus == MauPropertyStatus.ReadOnly)
{
throw new Exception($"This prop '{holder.MauId}.{PropertyName}' is 'ReadOnly'.");
}
SendMauProp(holder, PropertyName);
}
public void OnValueChange(LocationInterceptionArgs args)
{
if (!this.IsFrozen)
{
args.ProceedSetValue();
}
}
public void OnPropertySet(LocationInterceptionArgs args)
{
var vmInstance = args.Instance as ViewModelBase;
var convention = conventionManager.Convention(vmInstance, args.Location.Name);
convention.OnPropertySet(new PostSharpPropertyInfo(args));
}
public void OnFieldGet(LocationInterceptionArgs args)
{
if (runningConstructors != null && runningConstructors.Contains(args.Instance))
{
return;
}
ReaderWriterLockSlim myLock = ((IReaderWriterSynchronized)args.Instance).Lock;
if (myLock.IsReadLockHeld || myLock.IsUpgradeableReadLockHeld || myLock.IsWriteLockHeld)
{
return;
}
Dictionary <ReaderWriterLockSlim, ReadCheckNode> myRunningMethods = runningMethods;
ReadCheckNode node;
if (myRunningMethods == null || !myRunningMethods.TryGetValue(myLock, out node))
{
// The field is read from outside an instance method of the current instance.
// This can happen. This would not be a good practice, but this should be checked using an architectural constraint.
// TODO: Verify with architectural constraint.
return;
}
if (node.Count > 0)
{
throw new LockNotHeldException("A reader lock is necessary to access more than one field.");
}
node.Count = 1;
}
public void OnSetField( LocationInterceptionArgs args )
{
if ( this.IsFrozen )
throw new InvalidOperationException("The object is frozen.");
args.ProceedSetValue();
}
private void GetValue(LocationInterceptionArgs args, bool propagate = false)
{
var properties = args.Instance.GetType().GetProperties();
// JSONObject is just an object with string KEY and string VALUE, you can add dummy data here using a Dictionary<string, string>
IEnumerable <JSONObject> result = API.Methods.GetCharsetData(id, Charset).Result;
if (result.Count() > 0)
{
foreach (PropertyInfo propertyInfo in properties)
{
CatalogueLazyLoad attribute = propertyInfo.GetCustomAttribute <CatalogueLazyLoad>();
if (attribute != null && attribute.Charset == Charset)
{
propertyInfo.SetValue(args.Instance,
Convert.ChangeType(result.Where(x => x.Key == attribute.Name).Select(x => x.Value).FirstOrDefault(), propertyInfo.PropertyType, CultureInfo.CurrentCulture),
null);
}
}
if (propagate)
{
this.LoadedCategoriesProperty.Get().Add(this.Charset);
}
args.ProceedGetValue();
}
}
object GetValueFor([NotNull] LocationInterceptionArgs args, LazyEntity parent, Func <LazyEntity, Type, ICollection <IDataCriterion>, IEnumerable <object> > read)
{
var criterion = CriterionFor(args);
if (criterion == null)
{
return(null);
}
// var collection = GetLazy.Entity(RealLocationType, (ILazyEntity)args.Instance).By(criterion);
var collection = read(parent, RealLocationType, new[] { criterion });
if (IsCollection)
{
var targetCollection = (IList)Activator.CreateInstance(TargetCollectionType);
foreach (var item in collection)
{
targetCollection.Add(item);
}
return(targetCollection);
}
return(collection.FirstOrDefault());
}
public override void OnSetValue(LocationInterceptionArgs args)
{
args.ProceedSetValue();
Console.WriteLine("Writing to registry");
Registry.SetValue(this.keyName, this.valueName, Convert.ToString(args.Value));
this.isFetched = true;
}
public void OnPropertySet(LocationInterceptionArgs args)
{
var fireEvents = EventSettings.BubblingEnabled && FireOnPropertyChange;
var instance = Instance;
var locationName = args.LocationName;
if (fireEvents)
{
EditActionAttribute.FireBeforeEventCall(instance, true);
OnEntityEventMethod(instance, new PropertyChangingEventArgs(locationName),
EntityEventType.PropertyChanging);
}
try
{
args.ProceedSetValue();
}
finally
{
if (fireEvents)
{
try
{
OnEntityEventMethod(instance, new PropertyChangedEventArgs(locationName),
EntityEventType.PropertyChanged);
}
finally
{
EditActionAttribute.FireAfterEventCall(instance, true, false);
}
}
}
}
public void OnFieldSet(LocationInterceptionArgs args)
{
//If a thread-unsafe field is accessed in a way which ignores checks (e.g. from static method or other instance), an exception should be thrown
if (runningConstructors != null && runningConstructors.Contains(args.Instance))
{
return;
}
//Fields marked with ThreadSafe have already been exluded
object key = this.GetRunningThreadSafeMethodsKey(args.Instance, args.Location.DeclaringType);
if (IsContextThreadSafe(key))
{
return;
}
object sync = GetSyncObject(this.policy, args.Instance, args.Location.DeclaringType);
ThreadHandle threadHandle;
if (!locks.TryGetValue(sync, out threadHandle) || threadHandle.Thread != Thread.CurrentThread)
{
throw new LockNotHeldException(
"Fields not marked with ThreadSafe attribute can only be accessed from monitored ThreadUnsafe methods or methods marked as ThreadSafe.");
}
args.ProceedSetValue();
}
public void OnPropertySet(LocationInterceptionArgs args)
{
// Don't go further if the new value is equal to the old one.
// (Possibly use object.Equals here).
if (args.Value == args.GetCurrentValue())
{
return;
}
// Actually sets the value.
args.ProceedSetValue();
// Ignore properties with AutoDirtyIgnoreAttribute.
var propertyInfo = args.Location.PropertyInfo;
if (propertyInfo.GetCustomAttributes(typeof(AutoDirtyIgnoreAttribute), true).Any())
{
return;
}
if (Instance is IDirty dirtyObject)
{
dirtyObject.SetDirty();
}
}
public override void OnGetValue(LocationInterceptionArgs args)
{
if (args.GetCurrentValue() == null)
{
Console.WriteLine("Property ({0}) not initialized", args.LocationFullName);
}
}
public override void OnSetValue(LocationInterceptionArgs args)
{
var locationInfo = args.Location;
if (locationInfo.LocationType == typeof(string))
{
CrossSettings.Current.AddOrUpdateValue(args.LocationFullName, (string)args.Value);
args.ProceedSetValue();
return;
}
if (locationInfo.LocationType == typeof(double))
{
CrossSettings.Current.AddOrUpdateValue(args.LocationFullName, (double)args.Value);
args.ProceedSetValue();
return;
}
if (locationInfo.LocationType == typeof(Int32))
{
CrossSettings.Current.AddOrUpdateValue(args.LocationFullName, (Int32)args.Value);
args.ProceedSetValue();
return;
}
if (locationInfo.LocationType == typeof(Int64))
{
CrossSettings.Current.AddOrUpdateValue(args.LocationFullName, (Int64)args.Value);
args.ProceedSetValue();
return;
}
if (locationInfo.LocationType == typeof(bool))
{
CrossSettings.Current.AddOrUpdateValue(args.LocationFullName, (bool)args.Value);
args.ProceedSetValue();
return;
}
if (locationInfo.LocationType == typeof(decimal))
{
CrossSettings.Current.AddOrUpdateValue(args.LocationFullName, (decimal)args.Value);
args.ProceedSetValue();
return;
}
if (locationInfo.LocationType == typeof(DateTime))
{
CrossSettings.Current.AddOrUpdateValue(args.LocationFullName, (DateTime)args.Value);
args.ProceedSetValue();
return;
}
}
public override void OnGetValue(LocationInterceptionArgs args)
{
args.ProceedGetValue();
if (AlreadyLoaded)
{
return;
}
if (IsValueAlreadySpecified(args))
{
AlreadyLoaded = true;
return;
}
var lazyEntity = (LazyEntity)args.Instance;
if (!lazyEntity.Context.IsLoadingAllowed)
{
if (!IsCollection || args.Value != null)
{
return;
}
//? then property is collection - we initialize it with empty collection if it now initialized yet, to avoid null reference exceptions
InitializeCollectionPropertyWithEmptyCollection(args);
return;
}
LazyLoadValueFromDatabase(args, lazyEntity);
}
public override void OnSetValue(LocationInterceptionArgs args)
{
Console.WriteLine("OnSetValue" + args.Value ?? "Nil");
// 可在此把欲設定的值換掉。
args.Value = "I am deamon.";
base.OnSetValue(args);
}
public override void OnGetValue(LocationInterceptionArgs args)
{
if (this.isFetched)
{
args.ProceedGetValue();
return;
}
else
{
this.isFetched = true;
Console.WriteLine("Reading from registry");
string stringValue = Registry.GetValue(this.keyName, this.valueName, null) as string;
if (stringValue != null )
{
object value = Convert.ChangeType(stringValue, args.Location.LocationType);
args.SetNewValue(value);
args.Value = value;
}
else
{
args.ProceedGetValue();
}
}
}
void LazyLoadValueFromDatabase(LocationInterceptionArgs args, LazyEntity lazyEntity)
{
lock (_writeLock) {
args.ProceedGetValue();
if (AlreadyLoaded)
{
return;
}
if (IsValueAlreadySpecified(args))
{
AlreadyLoaded = true;
return;
}
if (lazyEntity.Read == null)
{
AlreadyLoaded = true; //?if Read callback is null - it means that entity was created by the client code, and not was getted from db, so it's not persisted at all.
return;
}
var value = GetValueFor(args, lazyEntity, lazyEntity.Read);
args.SetNewValue(value);
AlreadyLoaded = true;
args.ProceedGetValue();
}
}
public override void OnGetValue(LocationInterceptionArgs args)
{
base.OnGetValue(args);
if (DefaultProvider != null && !_defaultProviderSet)
{
_defaultProvider = (TypedValueProvider)Activator.CreateInstance(DefaultProvider);
_defaultProviderSet = true;
}
if (Get)
{
if (ConvertType == null)
{
ConvertType = args.Location.LocationType;
}
try
{
args.Value = Json ? JsonConvert.DeserializeObject(FlashUtil.Call(Name), ConvertType) : FlashUtil.Call(Name, ConvertType);
}
catch
{
args.Value = _defaultProvider.Provide(ConvertType);
}
}
}
public override void OnGetValue(LocationInterceptionArgs args)
{
Console.WriteLine("OnGetValue" + args.Value ?? "Nil");
base.OnGetValue(args);
// 可在此把取回的值換掉。
args.Value = "I am god!";
}
/// <summary>
/// Method invoked <i>instead</i> of the <c>Get</c> semantic of the field or property to which the current aspect is applied,
/// i.e. when the value of this field or property is retrieved.
/// </summary>
/// <param name="args">Advice arguments.</param>
public override void OnGetValue(LocationInterceptionArgs args)
{
args.ProceedGetValue();
if (args.Value == null)
{
if (string.IsNullOrEmpty(this.Token))
{
if (string.IsNullOrEmpty(this.TokenProperty))
{
args.Value = IoC.Get(args.Location.LocationType);
}
else
{
object value = ObjectProxyFactory.Get(args.Instance).GetValue(args.Instance, this.TokenProperty);
if (value == null)
{
args.Value = IoC.Get(args.Location.LocationType);
}
else
{
args.Value = IoC.Get(args.Location.LocationType, value.ToString());
}
}
}
else
{
args.Value = IoC.Get(args.Location.LocationType, this.Token);
}
args.ProceedSetValue();
}
}
public bool RefreshPropertyBindings(LocationInterceptionArgs args)
{
bool bindingFound = false;
List <FieldValueBinding> sourceFields;
if (this.TryGetSourceFieldBindings(args.LocationName, out sourceFields))
{
foreach (FieldValueBinding fieldValueBinding in sourceFields.OrderBy(f => f.IsActive))
{
object value = fieldValueBinding.Field.GetValue(args.Instance);
if (this.fieldValueComparer.AreEqual(args.LocationFullName, value, args.Value))
{
// field and property values are equal, mark source field binding as active and if there is a handler hooked to the property un hook it
bindingFound = true;
if (fieldValueBinding.IsActive)
{
break;
}
fieldValueBinding.IsActive = true;
}
else
{
// field and property values differ, mark source field binding as inactive and re hook a handler to the property
fieldValueBinding.IsActive = false;
}
}
}
return(bindingFound);
}
public UndoItem(UndoableAttribute parent, object newValue, object oldValue, LocationInterceptionArgs args)
{
this.newValue = newValue;
this.parent = parent;
this.oldValue = oldValue;
this.args = args;
}
/// <summary>
/// Method invoked <i>instead</i> of the <c>Get</c> semantic of the field or property to which the current aspect is applied,
/// i.e. when the value of this field or property is retrieved.
/// </summary>
/// <param name="args">Advice arguments.</param>
public override void OnGetValue(LocationInterceptionArgs args)
{
args.ProceedGetValue();
if (args.Value == null)
{
if (string.IsNullOrEmpty(this.Token))
{
if (string.IsNullOrEmpty(this.TokenProperty))
{
args.Value = IoC.Get(args.Location.LocationType);
}
else
{
object value = ObjectProxyFactory.Get(args.Instance).GetValue(args.Instance, this.TokenProperty);
if (value == null)
{
args.Value = IoC.Get(args.Location.LocationType);
}
else
{
args.Value = IoC.Get(args.Location.LocationType, value.ToString());
}
}
}
else
{
args.Value = IoC.Get(args.Location.LocationType, this.Token);
}
args.ProceedSetValue();
}
}
public override void OnGetValue(LocationInterceptionArgs args)
{
if (this.isFetched)
{
args.ProceedGetValue();
return;
}
else
{
this.isFetched = true;
var stringValue = ConfigurationManager.AppSettings[this.settingName];
if (!string.IsNullOrEmpty(stringValue))
{
var value = Convert.ChangeType(stringValue, args.Location.LocationType);
args.SetNewValue(value);
args.Value = value;
}
else
{
args.ProceedGetValue();
}
}
}
public override void OnGetValue(LocationInterceptionArgs args)
{
base.OnGetValue(args);
if (args.Value == null)
{
}
}
public override void OnSetValue(LocationInterceptionArgs args)
{
var resources = (args.Instance as FrameworkElement).Resources;
if (!resources.Contains(ResourceKey))
throw new KeyNotFoundException("The key '{0}' was not found in the resource dictionary.".FormatWith(ResourceKey));
resources[ResourceKey] = args.Value;
}
/// <summary>
/// Method executed when the field or property is being read.
/// </summary>
/// <param name="args">Description of the current operation.</param>
public void OnSetValue(LocationInterceptionArgs args)
{
RequirePermission(args.Location.FieldInfo ?? (MemberInfo)args.Location.PropertyInfo, OperationSemantic.Write, 0,
args.Instance);
args.ProceedSetValue();
}
public override void OnGetValue(LocationInterceptionArgs args)
{
if (!_valueSet)
{
_valueSet = true;
if (IsGuid)
{
//Console.WriteLine("Initializing Guid");
if (args.Location.LocationType == typeof(string))
args.SetNewValue(Guid.NewGuid().ToString());
else if (args.Location.LocationType == typeof(Guid))
args.SetNewValue(Guid.NewGuid());
}
else if (_defaultValue != null)
{
args.SetNewValue(_defaultValue);
//Console.WriteLine("Initialized {0} to |{1}|", args.LocationName, args.GetCurrentValue());
}
else if (args.Location.PropertyInfo.GetType().IsClass)
{
var t = args.Location.PropertyInfo.PropertyType;
if (t.GetConstructor(Type.EmptyTypes) != null)
{
//Console.WriteLine("Initializing {0}", args.LocationName);
args.SetNewValue(Activator.CreateInstance(t));
}
else throw new InvalidOperationException(string.Format("The property {0} (type {1}) has no default constructor and must either be provided with a default value or have the [Initialize] attribute removed", args.LocationFullName, t));
}
}
//Console.WriteLine("Before get called. Current value is |{0}|", args.GetCurrentValue());
args.ProceedGetValue();
//Console.WriteLine("After get called. Current value is |{0}|", args.Value);
}
public UndoItem( UndoableAttribute parent, object newValue, object oldValue, LocationInterceptionArgs args )
{
this.newValue = newValue;
this.parent = parent;
this.oldValue = oldValue;
this.args = args;
}
public override void OnSetValue(LocationInterceptionArgs Args)
{
this.Args = Args;
if (HasAValue) Value = KeyMaker.Encrypt(Value.ToString());
SetValue();
}
/// <inheritdoc />
public sealed override void OnGetValue(LocationInterceptionArgs args)
{
ReactiveManagerWithList.Evaluate(() =>
{
base.OnGetValue(args);
return((INotifyCollectionChanged)args.GetCurrentValue());
});
}
public override void OnGetValue(LocationInterceptionArgs args)
{
if (_backingField == null)
lock (_syncRoot)
if (_backingField == null)
_backingField = Activator.CreateInstance(args.Location.LocationType);
args.Value = _backingField;
}
public override void OnSetValue(LocationInterceptionArgs args)
{
if (null != GetEncryptedValues())
if (!GetEncryptedValues().ContainsKey(propname))
GetEncryptedValues().Add(propname, args.Value.ToString());
else
GetEncryptedValues()[propname] = args.Value.ToString();
}
public override void OnGetValue(LocationInterceptionArgs args)
{
if (args.GetCurrentValue() == null)
{
args.SetNewValue(_value);
}
args.ProceedGetValue();
}
/// <summary>
/// Method invoked <i>instead</i> of the <c>Get</c> semantic of the field or property to which the current aspect is applied,
/// i.e. when the value of this field or property is retrieved.
/// </summary>
/// <param name="args">Advice arguments.</param>
public override void OnGetValue(LocationInterceptionArgs args)
{
if (null == args.GetCurrentValue())
{
Console.WriteLine(string.Format("Property ({0}) not initialized",
args.LocationFullName));
}
}
public override void OnSetValue(LocationInterceptionArgs args)
{
if (HashedValuesStore.Get().ContainsKey(propname))
HashedValuesStore.Get()[propname] = HashValue(args.Value.ToString());
else
HashedValuesStore.Get().Add(propname, HashValue(args.Value.ToString()));
args.ProceedSetValue();
}
public sealed override void OnGetValue(LocationInterceptionArgs args)
{
ReactiveManager.Evaluate(new CompositeReactiveObject(args.Instance, property), () =>
{
args.ProceedGetValue();
return(true);
});
}
public void OnSetValue(LocationInterceptionArgs args)
{
if (args.Value != args.GetCurrentValue())
{
args.ProceedSetValue();
this.OnPropertyChanged(args.Location.Name);
}
}
public void OnSetValue( LocationInterceptionArgs args )
{
if ( args.Value != args.GetCurrentValue() )
{
args.ProceedSetValue();
this.OnPropertyChanged( args.Location.Name );
}
}
public void OnSetValue(LocationInterceptionArgs args)
{
if (ValidateDelegate((T)args.Value)?.Any() == true)
{
throw new ArgumentException("...");
}
args.ProceedSetValue();
}
public override void OnSetValue(LocationInterceptionArgs Args)
{
this.Args = Args;
if (Value == UserSetting) return;
UserSetting = Value;
Save();
}
/// <summary>
/// Method invoked <i>instead</i> of the <c>Get</c> semantic of the field or property to which the current aspect is applied,
/// i.e. when the value of this field or property is retrieved.
/// </summary>
/// <param name="args">Advice arguments.</param>
public override void OnGetValue(LocationInterceptionArgs args)
{
args.ProceedGetValue();
if (args.Value == null)
{
args.Value = LogManager.GetLogger(args.Location.DeclaringType);
args.ProceedSetValue();
}
}
/// <summary>
/// Method invoked when (instead of) the target field or property is retrieved.
/// </summary>
/// <param _name="args">Context information.</param>
public override void OnGetValue(LocationInterceptionArgs args)
{
object value = _viewState.Get()[_name];
if (value != null)
{
args.Value = value;
}
}
public void OnPropertySet(LocationInterceptionArgs args)
{
if (!this.propertySetList.Contains(args.LocationName))
{
this.propertySetList.Add(args.LocationName);
}
args.ProceedSetValue();
}
/// <summary>
/// Method invoked when (instead of) the target field or property is retrieved.
/// </summary>
/// <param name="args">Context information.</param>
public override void OnGetValue(LocationInterceptionArgs args)
{
var value = ViewState.Get()[name];
if (value != null)
{
args.Value = value;
}
}
public override void OnSetValue(LocationInterceptionArgs args)
{
if (args.Value != null)
{
args.Value = ((string)args.Value).Trim().ToLowerInvariant();
}
args.ProceedSetValue();
}
public override void OnGetValue(LocationInterceptionArgs args)
{
args.ProceedGetValue();
if (args.Value == null)
{
args.Value = IoCContainer.Resolver.TryGetInstance(args.Location.LocationType);
}
args.ProceedGetValue();
}
public void OnObservedCollectionPropertySet(LocationInterceptionArgs args)
{
var oldInstance = args.GetCurrentValue() as INotifyCollectionChanged;
var newInstance = args.Value as INotifyCollectionChanged;
if (oldInstance != null)
oldInstance.CollectionChanged -= ObservedCollectionHandlers[args.LocationName];
if (newInstance != null)
newInstance.CollectionChanged += ObservedCollectionHandlers[args.LocationName];
args.ProceedSetValue();
}
public void OnObservedReferencePropertySet(LocationInterceptionArgs args)
{
var oldInstance = args.GetCurrentValue() as INotifyPropertyChanged;
var newInstance = args.Value as INotifyPropertyChanged;
if (oldInstance != null)
oldInstance.PropertyChanged -= ObservedPropertyHandlers[args.LocationName].Invoke;
if (newInstance != null)
newInstance.PropertyChanged += ObservedPropertyHandlers[args.LocationName].Invoke;
args.ProceedSetValue();
}
public override void OnSetValue(LocationInterceptionArgs args)
{
var symmetric = SymmetricMetaData.NewRandom();
var encrypted = string.Format("{0}\0{1}",EncryptSymmetricKey(symmetric.Key.KeyBytes),EncryptData(args.Value.ToString(),symmetric));
if (null != EncryptedValuesStore.Get())
if (!EncryptedValuesStore.Get().ContainsKey(propname))
EncryptedValuesStore.Get().Add(propname, encrypted);
else
EncryptedValuesStore.Get()[propname] = encrypted;
}
public override void OnSetValue( LocationInterceptionArgs args )
{
string s = (string) args.Value;
if ( s == null )
throw new ArgumentNullException( args.Location.Name );
if ( !regex.IsMatch( s ) )
throw new ArgumentOutOfRangeException( args.Location.Name );
base.OnSetValue( args );
}
public void OnPropertyGet(LocationInterceptionArgs args)
{
if (args.Location.PropertyInfo.GetSetMethod(true) != null &&
!this.propertySetList.Contains(args.LocationName))
{
throw new PropertyNotInitializedException(args.LocationFullName);
}
args.ProceedGetValue();
}
public void OnPropertySet( LocationInterceptionArgs args )
{
// Don't go further if the new value is equal to the old one.
// (Possibly use object.Equals here).
if ( args.Value == args.GetCurrentValue() ) return;
// Actually sets the value.
args.ProceedSetValue();
this.OnPropertyChangedMethod.Invoke( args.Location.Name );
}
public override void OnGetValue(LocationInterceptionArgs args)
{
args.ProceedGetValue(); // this actually fetches the field and populates the args.Value
if (args.Value == null)
{
var activity = args.Instance as Activity;
if (activity == null) throw new ArgumentException("LazyViewAttribute can only be used within Activities");
args.SetNewValue(activity.FindViewById(_viewId));
args.ProceedGetValue();
}
}
public override void OnGetValue(LocationInterceptionArgs args)
{
if (_backingField == null)
lock (_syncRoot)
if (_backingField == null)
{
var locationType = args.Location.PropertyInfo.PropertyType;
_backingField = ObjectFactory.GetInstance(locationType);
}
args.Value = _backingField;
}
public void OnLocationSetValue(LocationInterceptionArgs args)
{
var proxy = GetProxy(args);
if (proxy != null)
{
proxy.InterceptSet(args.Binding, args.Value);
return;
}
args.ProceedSetValue();
}
public void OnSetValue( LocationInterceptionArgs args )
{
if ( args.Value != args.GetCurrentValue() )
{
args.ProceedSetValue();
// We don't pass the property name because the UI is bound to
// derived properties (DisplayName). We should track property
// dependencies to do this correctly.
this.OnPropertyChangedMethod(null);
}
}
public override void OnSetValue(LocationInterceptionArgs args)
{
if(EncryptionKeysStore.Get().ContainsKey(propname))
{
string keyName = EncryptionKeysStore.Get()[propname];
var encrypted = Encrypt(args.Value.ToString(), KeyServer.Get().GetKey(keyName));
if (null != EncryptedValuesStore.Get())
if (!EncryptedValuesStore.Get().ContainsKey(propname))
EncryptedValuesStore.Get().Add(propname, encrypted);
else
EncryptedValuesStore.Get()[propname] = encrypted;
}
}
public void OnPropertySet(LocationInterceptionArgs args)
{
if (args.Location.PropertyInfo.GetSetMethod(true) != null &&
args.Location.PropertyInfo.DeclaringType != typeof(ContextSpecificationBase) &&
this.propertySetList.Contains(args.LocationName))
{
throw new PropertyAlreadyInitializedException(args.LocationFullName);
}
this.propertySetList.Add(args.LocationName);
args.ProceedSetValue();
}
/// <summary>
/// Method intercepting all changes on field, making sure that the
/// setting value matches the regular expression
/// </summary>
/// <param name="locationInterceptionArgs">Location Interception Arguments</param>
//[OnLocationSetValueAdvice]
//[MulticastPointcut(Targets = MulticastTargets.Property,
// Attributes = MulticastAttributes.Public)]
public override void OnSetValue(LocationInterceptionArgs locationInterceptionArgs)
{
bool isValid = RegEXPatterns.MatchFound(
locationInterceptionArgs.Value.ToString(),
this.Pattern);
if (isValid == false)
{
return;
}
locationInterceptionArgs.ProceedSetValue();
}
