/// <summary> /// Creates temporary cache and sets value to the property /// </summary> /// <param name="aObject"> /// Object which needs value to be set <see cref="System.Object"/> /// </param> /// <param name="aProperty"> /// Property name <see cref="System.String"/> /// </param> /// <param name="aValue"> /// New property value <see cref="System.Object"/> /// </param> /// <returns> /// true if successful, false if not <see cref="System.Boolean"/> /// </returns> public static bool UncachedSetValue(object aObject, string aProperty, object aValue) { bool res = false; CachedProperty tempCache = new CachedProperty(aObject, aProperty); if (tempCache.IsAccessValid == EPropertyAccess.Valid) { res = tempCache.SetValue(aObject, aProperty, aValue); } tempCache.Disconnect(); tempCache = null; return(res); }
/// <summary> /// Sets value to cached property /// </summary> /// <param name="aObject"> /// Object where property resides <see cref="System.Object"/> /// </param> /// <param name="aProperty"> /// Property name <see cref="System.String"/> /// </param> /// <param name="aValue"> /// New value <see cref="System.Object"/> /// </param> /// <param name="aDefaultValue"> /// Default value which should be returned if method was unsuccessful <see cref="System.Object"/> /// </param> /// <returns> /// true if successful, false if not <see cref="System.Boolean"/> /// </returns> public bool GetValue(object aObject, string aProperty, out object aValue, object aDefaultValue) { bool startMethod = false; aValue = aDefaultValue; if (IsCached == true) { if (aProperty == PropertyName) { startMethod = true; } } else { if (IsCompatible(aObject) == true) { if (aProperty == PropertyName) { startMethod = IsCached; } } } // Start copying data if (startMethod == true) { if (IsProperty == true) { aValue = ConnectionProvider.GetPropertyValue(aObject, propInfo); return(true); } if (IsVirtualProperty == true) { aValue = propVirtual.Value; return(true); } if (IsDataRowField == true) { return(DatabaseProvider.GetValue(aObject, propColumn, out aValue, aDefaultValue)); } throw new ExceptionCachedPropertyGetValueFailed(this); } else { // If method arrived here then this is not a valid cache for that property // fallback creates temporary cache and gets value trough it return(CachedProperty.UncachedGetValue(aObject, aProperty, out aValue, aDefaultValue)); } return(false); }
/// <summary> /// Creates temporary cache and gets value from the property /// </summary> /// <param name="aObject"> /// Object which needs value to be set <see cref="System.Object"/> /// </param> /// <param name="aProperty"> /// Property name <see cref="System.String"/> /// </param> /// <param name="aValue"> /// Property value <see cref="System.Object"/> /// </param> /// <param name="aDefaultValue"> /// Default value which should be returned if method was unsuccessful <see cref="System.Object"/> /// </param> /// <returns> /// true if successful, false if not <see cref="System.Boolean"/> /// </returns> public static bool UncachedGetValue (object aObject, string aProperty, out object aValue, object aDefaultValue) { aValue = aDefaultValue; bool res = false; CachedProperty tempCache = new CachedProperty (aObject, aProperty); if (tempCache.IsAccessValid == EPropertyAccess.Valid) res = tempCache.GetValue (aObject, aProperty, out aValue, aDefaultValue); tempCache.Disconnect(); tempCache = null; return (res); }
/// <summary> /// Disconnects on adaptors OnTargetChange /// </summary> public void Disconnect() { if (dataCache != null) dataCache.Disconnect(); dataCache = null; if (controlCache != null) controlCache.Disconnect(); controlCache = null; if (IsSubItem == true) MasterItem.Submappings.RemoveMapping (this); else if (submappings != null) submappings.Disconnect(); submappings = null; masterItem = null; if (Adaptor != null) { Adaptor.TargetChanged -= TargetChanged; adaptor.Target = null; } adaptor = null; }
/// <summary> /// Assigns Value in given direction between Control and DataSource Target /// </summary> /// <param name="aDirection"> /// Direction of data <see cref="EDataDirection"/> /// </param> /// <param name="aObject"> /// Object which contains data <see cref="System.Object"/> /// </param> /// <param name="aControl"> /// Control used to edit <see cref="System.Object"/> /// </param> /// <returns> /// Returns true if successful <see cref="System.Boolean"/> /// </returns> public bool AssignValueToObject (EDataDirection aDirection, object aObject, object aControl) { bool res = false; // Check if if (IsGlobal == true) { if (aDirection == EDataDirection.FromControlToDataSource) throw new ExceptionGlobalMappingAssignedFromControlToTarget(); #if NEWCACHE if (dataCache == null) dataCache = new CachedProperty (Adaptor.FinalTarget, Name); if (controlCache == null) controlCache = new CachedProperty (aControl, MappingTarget); if (controlCache.IsCached == true) { object val; if (dataCache.IsCached == true) if (dataCache.GetValue (out val) == true) if (controlCache.SetValue (val) == true) { val = null; return (true); } } return (false); #endif #if OLDCACHE object FromObject = aObject; object ToObject = aControl; string FromProperty = Name; string ToProperty = MappingTarget; // assign, direction is already correct res = ConnectionProvider.CopyPropertyValue (FromObject, FromProperty, ToObject, ToProperty); FromObject = null; ToObject = null; return (res); #endif } else { #if NEWCACHE CachedProperty FromObject; CachedProperty ToObject; bool canbedone; if (aDirection == EDataDirection.FromControlToDataSource) { FromObject = controlCache; ToObject = dataCache; canbedone = AllowedToWrite; if (ToObject is IObserveable) (ToObject as IObserveable).ResetChangeCallCheckup(); } else { FromObject = dataCache; ToObject = controlCache; canbedone = AllowedToRead; } if (controlCache == null) controlCache = new CachedProperty (aControl, MappingTarget); object val = null; // assign in set direction if ((canbedone == true) && (FromObject != null) && (ToObject != null)) { if (FromObject.GetValue (out val) == true) { if (ToObject.SetValue (val) == true) if (aDirection == EDataDirection.FromControlToDataSource) if ((ToObject is IObserveable) == false) DataSourceController.CallChangedFor (ToObject); else if ((ToObject as IObserveable).HasCalledForChange == false) (ToObject as IObserveable).HasChanged = true; res = true; } } FromObject = null; ToObject = null; return (res); #endif #if OLDCACHE object FromObject; object ToObject; string FromProperty; string ToProperty; bool canbedone; // swap direction if needed if (aDirection == EDataDirection.FromControlToDataSource) { FromObject = aControl; ToObject = aObject; FromProperty = MappingTarget; ToProperty = Name; canbedone = AllowedToWrite; if (ToObject is IObserveable) (ToObject as IObserveable).ResetChangeCallCheckup(); } else { FromObject = aObject; ToObject = aControl; FromProperty = Name; ToProperty = MappingTarget; canbedone = AllowedToRead; } // assign in set direction if (canbedone == true) { if (ConnectionProvider.CopyPropertyValue(FromObject, FromProperty, ToObject, ToProperty) == true) { if (aDirection == EDataDirection.FromControlToDataSource) if ((ToObject is IObserveable) == false) DataSourceController.CallChangedFor (ToObject); else if ((ToObject as IObserveable).HasCalledForChange == false) (ToObject as IObserveable).HasChanged = true; res = true; } // else // Debug.Warning ("MappedProperty.AssignValueToObject", "CopyPropertyValue not successful"); } FromObject = null; ToObject = null; return (res); #endif } }
/// <summary> /// Resoves PropertyInfo from connected object /// </summary> public bool Resolve() { #if NEWCACHE if (dataCache == null) dataCache = new CachedProperty (Adaptor.FinalTarget, Name); if (resetResolve == true) { dataCache.SetObject (Adaptor.FinalTarget); dataCache.SetProperty (Name.Trim()); } /* if (dataCache.IsAccessValid == EPropertyAccess.Invalid) if (Adaptor.FinalTarget != null) { dataCache.SetObject (Adaptor.FinalTarget); dataCache.SetProperty (Name.Trim()); }*/ return (dataCache.IsAccessValid == EPropertyAccess.Valid); #endif #if OLDCACHE if (cached == true) return (true); if (name == "") return (false); cached = false; cachedInfo = null; if (Adaptor.FinalTarget != null) cachedInfo = ConnectionProvider.ResolveMappingProperty (Adaptor.FinalTarget, Name, false); cached = (cachedInfo != null); invalid = (cachedInfo == null); return (cachedInfo != null); #endif }
/// <summary> /// Creates temporary cache and gets value from the property /// </summary> /// <param name="aObject"> /// Object which needs value to be set <see cref="System.Object"/> /// </param> /// <param name="aProperty"> /// Property name <see cref="System.String"/> /// </param> /// <param name="aValue"> /// Property value <see cref="System.Object"/> /// </param> /// <returns> /// true if successful, false if not <see cref="System.Boolean"/> /// </returns> /// <remarks> /// calls CachedProperty.UncachedGetValue with null as default value /// </remarks> public static bool UncachedGetValue(object aObject, string aProperty, out object aValue) { return(CachedProperty.UncachedGetValue(aObject, aProperty, out aValue, null)); }