public IList <KeyValuePair <string, IStateObject> > GetAllDependentItems(IStateObject elementObj, List <KeyValuePair <string, IStateObject> > result = null)
{
var dependentsContainer = elementObj as IDependentsContainer;
if (dependentsContainer != null)
{
var count = dependentsContainer.Dependents != null ? dependentsContainer.Dependents.Count : 0;
if (count > 0)
{
if (result == null)
{
result = new List <KeyValuePair <string, IStateObject> >(50);
}
var uniqueIDPart = UniqueIDGenerator.UniqueIdSeparatorStr + elementObj.UniqueID;
for (int i = 0; i < count; i++)
{
var childKey = dependentsContainer.Dependents[i];
var childUniqueID = childKey;
if (!UniqueIDGenerator.IsListItem(childKey))
{
childUniqueID += uniqueIDPart;
}
T childValue;
if (cache.TryGetValue(childUniqueID, out childValue))
{
result.Add(new KeyValuePair <string, IStateObject>(childUniqueID, (IStateObject)childValue));
GetAllDependentItems((IStateObject)childValue, result);
}
}
}
}
return(result ?? EMPTYDEPENDENTS2);
}
private void PublishInternal(string eventId, IStateObject source, object[] args)
{
eventId = eventId.ToUpper();
var promisesInfo = HasSubscribers(eventId, source) as PromisesInfo;
if (promisesInfo != null)
{
foreach (string eventsnameid in promisesInfo.GetListMethodsMame())
{
var subscriptionId = UniqueIDGenerator.GetEventRelativeUniqueID(source, eventsnameid);
var eventHandlerInfo = _stateManager.GetObject(subscriptionId) as EventPromiseInfo;
if (eventHandlerInfo != null)
{
this.PublishInternal(eventHandlerInfo, eventId, source, false, args);
}
else
{
TraceUtil.TraceError(string.Format("EventAggregator::PublishInternal. No Events found for EventId [{0}] on object [{1}]", subscriptionId, source == null ? "null" : source.UniqueID));
}
}
}
else
{
TraceUtil.TraceError(string.Format("HandlersEventAggregator::PublishInternal. No Events found for EventId [{0}] on object [{1}]", eventId, source == null ? "null" : source.UniqueID));
}
}
/// <summary>
/// Will register a subscriber. Event will be recognized by "eventId" and will be attached to
/// obj
/// </summary>
/// <param name="eventId"></param>
/// <param name="obj"></param>
/// <param name="handler"></param>
public void Subscribe(string eventId, IStateObject obj, Delegate handler, out string eventSubscriptionId, bool isDynamic = false)
{
var result = String.Empty;
if (handler != null)
{
//get/created subscribed promises info
eventId = eventId.ToUpper();
var handlerSubscriptionId = UniqueIDGenerator.GetEventRelativeUniqueID(obj, eventId);
LazyBehaviours.AddDependent(obj, UniqueIDGenerator.EVENTPrefix + eventId);
var promisesInfo = PromisesInfo.CreateInstance(handlerSubscriptionId);
////subscribe handler
var eventMethodName = handler.Method.Name.ToUpper() + eventId;
eventSubscriptionId = UniqueIDGenerator.GetEventRelativeUniqueID(obj, eventMethodName);
LazyBehaviours.AddDependent(obj, UniqueIDGenerator.EVENTPrefix + eventMethodName);
promisesInfo.Add(eventMethodName);
if (isDynamic)
{
EventPromiseInfoForClient.CreateEventInstance(_stateManager, handler, obj, eventSubscriptionId, actionID: eventId);
}
else
{
EventPromiseInfo.CreateEventInstance(_stateManager, handler, obj, eventSubscriptionId);
}
#if DEBUG
Debug.Assert(_stateManager.GetObject(eventSubscriptionId) != null, "Event Subscription Failed", "Event for {0} on Object {1} failed", eventId, obj.UniqueID);
#endif
result = eventSubscriptionId;
}
eventSubscriptionId = result;
}
public Delegate PublishToDelegate(string eventId, IStateObject source)
{
eventId = eventId.ToUpper();
var promisesInfo = HasSubscribers(eventId, source) as PromisesInfo;
if (promisesInfo != null)
{
foreach (string eventsnameid in promisesInfo.GetListMethodsMame())
{
var subscriptionId = UniqueIDGenerator.GetEventRelativeUniqueID(source, eventsnameid);
var eventHandlerInfo = _stateManager.GetObject(subscriptionId) as EventPromiseInfo;
if (eventHandlerInfo != null)
{
var result = this.PublishInternal(eventHandlerInfo, eventId, source, true, null);
return(result);
}
else
{
TraceUtil.TraceError(string.Format("EventAggregator::PublishToMainSyncronizationContext. No Events found for EventId [{0}] on object [{1}]", subscriptionId, source == null ? "null" : source.UniqueID));
}
}
}
else
{
TraceUtil.TraceError(string.Format("HandlersEventAggregator::PublishToMainSyncronizationContext. No Events found for EventId [{0}] on object [{1}]", eventId, source == null ? "null" : source.UniqueID));
}
return(null);
}
/// <summary>
/// Goes through all the References Tables in a branch and Updates the References.
/// </summary>
/// <param name="branchDeleted"></param>
/// <param name="oldParentUID"></param>
/// <param name="newParentUID"></param>
public void UpdateReferencesTables(string oldParentUID, string newParentUID)
{
var newParentUIDRefTables = GetChildrenReferencesTables(newParentUID);
if (newParentUIDRefTables != null)
{
foreach (var table in newParentUIDRefTables)
{
var newUID = StateManager.GetParentUniqueID(table.UniqueID);
var oldUID = UniqueIDGenerator.ReplaceParent(newUID, newParentUID, oldParentUID);
//Let´s update and then validate the References.
table.UpdateReferencesTable(oldParentUID, newParentUID, oldUID, newUID);
}
}
var olParentUIDRefTables = GetChildrenReferencesTables(oldParentUID);
if (olParentUIDRefTables != null)
{
for (var i = 0; i < olParentUIDRefTables.Count; i++)
{
var table = olParentUIDRefTables[i];
//Maybe table is already in ElementsToRemove
if (table != null)
{
var newUID = StateManager.GetParentUniqueID(table.UniqueID);
var oldUID = UniqueIDGenerator.ReplaceParent(newUID, newParentUID, oldParentUID);
//Let´s update and then validate the References.
table.UpdateReferencesTable(oldParentUID, newParentUID, oldUID, newUID);
}
}
}
}
internal static bool ProcessGetterTopLevelIStateObject(PropertyInfoEx propEx, object parentObject, ref Object lastValue)
{
if (lastValue == null)
{
var prop = propEx.prop;
var parentInstance = parentObject as IStateObject;
if (typeof(IStateObject).IsAssignableFrom(prop.DeclaringType))
{
Type returnType = prop.PropertyType;
var stateManager = StateManager.Current;
var attributes = returnType.GetCustomAttributes(typeof(Singleton), false);
if (attributes.Length > 0)
{
var cachedValue = stateManager.GetObject(UniqueIDGenerator.GetSinglentonUniqueId(returnType));
lastValue = cachedValue;
return(true);
}
else
{
var propName = GetPropertyName(propEx);
var relativeUid = UniqueIDGenerator.GetPointerRelativeUniqueID(parentInstance, propName);
var pointer = (StateObjectPointer)stateManager.GetObject(relativeUid);
if (pointer != null)
{
var cachedValue = TryToRecoverWithPointer(stateManager, propEx, parentInstance, false, pointer: pointer);
lastValue = cachedValue;
return(true);
}
}
}
}
return(false);
}
public void UnSubscribe(object valueObject, string UniqueID, bool removeDirectly = false, string rootUniqueID = "")
{
var referenceToTheValue = valueObject as IStateObject;
if (referenceToTheValue != null)
{
var referencesTable = GetObjectReferencesTable(UniqueID);
if (referencesTable != null)
{
if (rootUniqueID != "")
{
referencesTable.ValidateReferences(validateUnAttached: true, branchDeleted: rootUniqueID);
}
else
{
referencesTable.ValidateReferences(validateUnAttached: true);
}
if (UniqueIDGenerator.IsListItem(UniqueID) && !HasValidReferencesForListItem(referencesTable, UniqueID, _stateManager._objectsToBeValidatedAfterDisposeHashSet))
{
_stateManager.DettachListItem(UniqueID, rootUniqueID);
}
else if (referencesTable.Count == 0 && !referencesTable.AttachedToParent)
{
_stateManager.DettachObject(UniqueID, false);
}
}
}
}
internal static bool ProcessGetterStrongReference(PropertyInfoEx propEx, object parentObject, ref Object lastResult)
{
var prop = propEx.prop;
var parentInstance = parentObject as IStateObject;
string propName = GetPropertyName(propEx);
//Try to recover
//1. First recover pointer
//2. Then get surrogate
string relativeUid = UniqueIDGenerator.GetPointerRelativeUniqueID(parentInstance, propName);
var stateManager = StateManager.Current;
var pointer = (StateObjectPointer)stateManager.GetObject(relativeUid);
if (pointer != null)
{
if (propEx.stateManagementAttribute == StateManagementValues.ServerOnly)
{
stateManager.isServerSideOnly.Add(pointer);
}
//Extend to support other types
var cachedValue = TryToRecoverWithPointer(stateManager, propEx, parentInstance, false, false, pointer: pointer);
lastResult = cachedValue;
return(true);
}
else
{
//There was no pointer, then return null
lastResult = null;
return(true);
}
}
private bool HasValidReferencesForListItem(ReferencesTable referencesTable, string uniqueID, HashSet <string> _objectsToBeValidatedAfterDisposeHashSet)
{
var isValid = false;
for (int i = referencesTable.References.Count - 1; i >= 0; i--)
{
var reference = referencesTable.References[i];
bool isPage = UniqueIDGenerator.IsPage(reference.TargetUniqueID);
if (isPage)
{
var page = reference.Target as Page;
string pageParentUniqueID = GetPageParentUniqueID(page);
//the reference is valid if and only if the list is not in elements to remove, and if the list is allbranchesattached.
if (!StateManager.Current.IsInElementsToRemove(pageParentUniqueID) &&
StateManager.AllBranchesAttached(pageParentUniqueID))
{
isValid = true;
}
}
else if (!StateManager.Current.IsInElementsToRemove(reference.TargetUniqueID))
{
//if the reference is not a page, this means it is a pointer pointing to the list item
// and this pointer is not in elementsToRemove Collection
//so this item has valid reference yet.
isValid = true;
_objectsToBeValidatedAfterDisposeHashSet.Add(uniqueID);
}
}
return(isValid);
}
/// <summary>
/// Rescues a Value if it has Valid References
/// </summary>
/// <param name="valueDeleted">It's the UniqueID of the IStateObject being deleted</param>
/// <param name="branchUniqueID">It's the Root object that started the Deletion process.</param>
/// <returns>True if the Value had valid references and it was rescued from deletion.</returns>
internal bool RescueValue(string objToRemoveUniqueID, string branchUniqueID = null, bool allowUnAttachedReferences = true, bool isDispose = false, IFormBaseViewModel formBaseViewModel = null, HashSet <string> _objectsToBeValidatedAfterDisposeHashSet = null)
{
if (branchUniqueID == null)
{
branchUniqueID = objToRemoveUniqueID;
}
var referencesTable = GetObjectReferencesTable(objToRemoveUniqueID);
if (referencesTable != null)
{
referencesTable.ValidateReferences(branchDeleted: branchUniqueID, validateUnAttached: !allowUnAttachedReferences);
//If the object to be removed is a ListItem AND the referencesTable's count is major than zero,
//then we have a special block for handling this situation.
if (UniqueIDGenerator.IsListItem(objToRemoveUniqueID) && referencesTable.Count > 0)
{
//If the referenced object is IViewModel, or IDisposableDependencyControl,
//we should never rescue them.
if (isDispose && referencesTable.IsReferencedObjectAnIDisposableDependencyControl)
{
return(false);
}
//If there are some valid references, we should rescue it.
else if (HasValidReferencesForListItem(referencesTable, objToRemoveUniqueID, _objectsToBeValidatedAfterDisposeHashSet))
{
RescuedValueUniqueIdHashSet.Add(objToRemoveUniqueID);
return(true);
}
//otherwise, we shouldn't resue it
else
{
return(false);
}
}
else if (referencesTable.Count > 0)//No references
{
bool res = TransferValueToReference(branchUniqueID, referencesTable, isDispose: isDispose, formBaseViewModel: formBaseViewModel);
if (res)
{
RescuedValueUniqueIdHashSet.Add(objToRemoveUniqueID);
}
return(res);
}
}
//Given this kind of uniqueID: x#y#KIXYZ
// We have to validate if KIXYZ has been rescued previously,
// if this KIXYZ has been rescued, we should skip this uniqueID
var accessPathIndex = objToRemoveUniqueID.LastIndexOf(UniqueIDGenerator.UniqueIdSeparator);
if (accessPathIndex > 0)
{
var ancestorUID = objToRemoveUniqueID.Substring(accessPathIndex + 1);
var canRescue = RescuedValueUniqueIdHashSet.Contains(ancestorUID) && !_stateManager.IsInElementsToRemove(ancestorUID);
if (UniqueIDGenerator.IsListItem(ancestorUID) && canRescue)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Creates a reference table to an Object.
/// </summary>
/// <param name="valueObject"></param>
/// <returns></returns>
private ReferencesTable CreateObjectReferencesTable(IStateObject valueObject)
{
var new_relativeUid = UniqueIDGenerator.GetReferenceTableRelativeUniqueID(valueObject.UniqueID);
LazyBehaviours.AddDependent(valueObject, UniqueIDGenerator.REFTABLEPrefix);
ReferencesTable referencesTable = new ReferencesTable();
referencesTable.UniqueID = new_relativeUid;
referencesTable.IsReferencedObjectAnIDisposableDependencyControl = valueObject is IDisposableDependencyControl;
if (StateManager.AllBranchesAttached(valueObject))
{
//at this point we have a new pointer with an attached parent
//which means that it was born on the temp stateManager
//we cannot just do a switchunique ids because switching
//is only on the stateManager level
//we need to promote it from temp to StateManager
//to make sure that it will be persisted
_stateManager.AddNewAttachedObject(referencesTable);
}
else
{
//at this point we have a new pointer with an UNATTACHED parent
//which means both the parent and the pointer are on the temp stateManager
//we need to switchunique ids because
//they are at the stateManager level
//if the parent is promoted so will be the pointer
_stateManager.AddNewTemporaryObject(referencesTable);
}
return(referencesTable);
}
public IList <string> GetAllDependentKeys(IStateObject elementObj, List <string> result = null)
{
var dependentsContainer = elementObj as IDependentsContainer;
if (dependentsContainer != null)
{
var dependents = dependentsContainer.Dependents;
var count = dependents != null ? dependents.Count : 0;
if (count > 0)
{
if (result == null)
{
result = new List <string>(50);
}
var uniqueIDPart = UniqueIDGenerator.UniqueIdSeparatorStr + elementObj.UniqueID;
for (int i = 0; i < count; i++)
{
var childKey = dependents[i];
var childUniqueID = childKey;
if (!UniqueIDGenerator.IsListItem(childKey))
{
childUniqueID += uniqueIDPart;
}
var childValue = stateManager.GetObject(childUniqueID);
if (childValue != null)
{
result.Add(childUniqueID);
GetAllDependentKeys((IStateObject)childValue, result);
}
}
}
}
return(result ?? EMPTYDEPENDENKEYS);
}
private IList <BasePromiseInfo> CreatePromises()
{
var stateCache = StateManager.Current;
var uid = UniqueIDGenerator.GetRelativeUniqueID(this, "Promises");
var promises = IocContainerImplWithUnity.Current.Resolve <IList <BasePromiseInfo> >();
stateCache.PromoteObject((IStateObject)promises, uid);
return(promises);
}
//private int AdoptToAttachedParent(IOrderedEnumerable<OrphanInfoEntry> sortedOrphans)
//{
// var adoptedOrphants = 0;
// var current = StateManager.Current;
// var tempCacheValues = current._tempcache.Values;
// var cacheValues = current._cache.Values;
// foreach (var orphanInfo in sortedOrphans)
// {
// //Is parent attached?
// //if (!tempCacheValues.Contains(orphanInfo.Parent, new CustomComparer()))
// //{
// // Adopt(orphanInfo.Parent, orphanInfo.Orphan);
// // this._currentOrphans.Remove(orphanInfo);
// // adoptedOrphants++;
// //}
// if (current._tempcache.GetIndexedKeyByValue(orphanInfo.Parent) == null)
// {
// Adopt(orphanInfo.Parent, orphanInfo.Orphan);
// _currentOrphans.Remove(orphanInfo);
// adoptedOrphants++;
// }
// //if (cacheValues.Contains(orphanInfo.Parent, new CustomComparer()))
// //{
// // Adopt(orphanInfo.Parent, orphanInfo.Orphan);
// // this._currentOrphans.Remove(orphanInfo);
// // adoptedOrphants++;
// //}
// }
// return adoptedOrphants;
//}
internal void Dispose()
{
this._currentOrphans = null;
this._godparentsOrphansAssignment = null;
this._orphanHolders = null;
this._promotedOrphans = null;
this._stateManager = null;
this._uniqueIdGenerator = null;
this.orphanInformationTables = null;
}
/// <summary>
/// Let's get the reference candidate for the adoption.
/// </summary>
/// <param name="referencedObject"></param>
/// <param name="onlyAllBranchesAttached"></param>
/// <returns></returns>
public IStateObject GetReferenceValidForAdoption(ReferencesTable referencesTable, bool onlyAllBranchesAttached = true, bool isHandlingOrphans = false)
{
IStateObject result = null;
if (referencesTable != null)
{
IStateObject firstNonVisualParentCandidate = null;;
IStateObject firstVisualParentCandidate = null;
foreach (var candidate in referencesTable.References)
{
var parent = CalculateCandidateForAdoption(candidate.Target as IStateObject);
//If the possible parent is a page, lets retrieve tha page's parent ( the list ), he will be the candidate
//who will compete with other parents in the addoption process.
if (isHandlingOrphans && parent is Page)
{
if ((parent as Page).Parent is IStateObject)
{
parent = (parent as Page).Parent as IStateObject;
}
else
{
parent = StateManager.Current.GetObject((parent as Page).Parent as string);
}
}
if (parent == null)
{
continue;
}
if (!onlyAllBranchesAttached || (onlyAllBranchesAttached && StateManager.AllBranchesAttached(parent)))
{
var isTopModel = UniqueIDGenerator.IsRootModel(parent.UniqueID);
var isTopShared = UniqueIDGenerator.IsRootSharedState(parent.UniqueID);
if (isTopModel || isTopShared || parent is IModel || parent is IDependentModel || parent is IPromise)
{
firstNonVisualParentCandidate = parent;
continue;
}
if (parent is IViewModel || parent is IDependentViewModel)
{
firstVisualParentCandidate = parent;
break;
}
}
}
if (firstVisualParentCandidate != null)
{
result = firstVisualParentCandidate;
}
else if (firstNonVisualParentCandidate != null)
{
result = firstNonVisualParentCandidate;
}
}
return(result);
}
/// <summary>
/// Gets the References table associated to an IStateObject
/// </summary>
/// <param name="valueObject"></param>
/// <returns></returns>
private ReferencesTable GetObjectReferencesTable(string uniqueID)
{
ReferencesTable result = null;
var uniqueId = UniqueIDGenerator.GetReferenceTableRelativeUniqueID(uniqueID);
var obj = _stateManager.GetObject(uniqueId);
if (obj != null)
{
result = obj as ReferencesTable;
}
return(result);
}
private static void ProcessStaticAdoption(IStateObject parent, IStateObject orphan)
{
//if (child is still orphan)
if (!StateManager.AllBranchesAttached(orphan))
{
//Get relative id for orphan
var orphanID = StateManager.Current.UniqueIDGenerator.GetOrphanUniqueID();
var newUniqueID = UniqueIDGenerator.GetRelativeUniqueID(parent, orphanID);
LazyBehaviours.AddDependent(parent, orphanID);
StateManager.Current.SwitchOrPromoteObject(orphan, newUniqueID, inAdoption: true);
}
}
private void GetResolvedValueEx(DependencyResolutionInfo dependency)
{
var surrogateManager = _stateManager.surrogateManager;
var value = dependency.value;
var istateObjectValue = dependency.value as IStateObject;
if (istateObjectValue != null)
{
//The value is an state object
if (_stateManager.IsInElementsToRemove(istateObjectValue.UniqueID))
{
//If the object is present in the elements it is detached from so its UniqueID
//is changed to a temporal one.
//The current in the session must be removed
_stateManager.DettachObject(istateObjectValue);
}
dependency.canBeAnOrphan = !StateManager.AllBranchesAttached(istateObjectValue);
dependency.ResolvedValue = istateObjectValue;
dependency.IsStateObject = true;
}
else if (value is ISurrogateEventsInfo)
{
dependency.ResolvedValue = value;
dependency.isEventsInfo = true;
}
else
{
//if (surrogateManager.IsSurrogateRegistered(value.GetType())) Commented for performance
StateObjectSurrogate currentSurrogate = null;
//Get the surrogate instance from the surrogates that are already loaded in memory or create one
dependency.ResolvedValue = currentSurrogate = dependency.ResolvedSurrogate = surrogateManager.GetSurrogateFor(value, generateIfNotFound: true);
if (currentSurrogate == null)
{
throw new ArgumentException("A surrogate could not be gotten for value of type " + value.GetType().FullName);
}
if (_stateManager.IsInElementsToRemove(currentSurrogate.UniqueID))
{
//If the object is present in the elements it is restored,
//since it is a top element no adoption needs to be performed
_stateManager.UndoRemove(currentSurrogate.UniqueID);
//We must unremove the Value surrogate
var valueUniqueID = UniqueIDGenerator.GetRelativeUniqueID(currentSurrogate, StateObjectSurrogate.VALUE_PREFIX);
_stateManager.UndoRemove(valueUniqueID);
}
else
{
//OK
}
}
}
public IStateObject HasSubscribers(string eventId, IStateObject source)
{
eventId = eventId.ToUpper();
if (source == null)
{
TraceUtil.TraceError("EventAggregator::PublishHighPriorityEvent Error publishing event [" + eventId + "] source argument should not be null");
return(null);
}
var subscriptionId = UniqueIDGenerator.GetEventRelativeUniqueID(source, eventId);
var promisesInfo = _stateManager.GetObject(subscriptionId) as PromisesInfo;
return(promisesInfo);
}
public T ResolveSinglenton <T>(object[] parameters = null, IIocContainerFlags flags = IIocContainerFlags.None)
{
var t = typeof(T);
T newInstance = default(T);
var stateManager = StateManager.Current;
try
{
var isRecoveredFromStorage = (flags & IIocContainerFlags.RecoveredFromStorage) == IIocContainerFlags.RecoveredFromStorage;
if (!isRecoveredFromStorage)
{
flags = flags | IIocContainerFlags.IsSinglenton;
newInstance = (T)stateManager.GetObject(UniqueIDGenerator.GetSinglentonUniqueId(t));
if (newInstance != null)
{
return(newInstance);
}
if ((flags & IIocContainerFlags.SinglentonNonReturnIfExisting) == IIocContainerFlags.SinglentonNonReturnIfExisting)
{
return(default(T));
}
//At this point the object was recovered from storage and it the RecoveredFromStorageFlags must
//added to avoid unnecessary further processing of this object
isRecoveredFromStorage = (newInstance != null);
}
if (newInstance == null)
{
newInstance = (T)ResolveUnPrepared(t, isRecoveredFromStorage);
}
if (newInstance is ILogic)
{
InitializeObject(stateManager, this, (ILogic)newInstance, parameters, t, isRecoveredFromStorage, flags);
}
else if (newInstance is IStateObject)
{
if (!isRecoveredFromStorage)
{
InitializeObject(stateManager, this, (IStateObject)newInstance, parameters, t, flags);
}
}
}
finally
{
if (newInstance is IStateObject)
{
stateManager.RemoveIDInResolution(((IStateObject)newInstance).UniqueID);
}
}
return(newInstance);
}
private bool ProcessAdoption(IStateObject parent, IStateObject orphan)
{
if (!_promotedOrphans.Contains(orphan))
{
//Get relative id for orphan
var orphanID = _uniqueIdGenerator.GetOrphanUniqueID();
var newUniqueID = UniqueIDGenerator.GetRelativeUniqueID(parent, orphanID);
_stateManager.PromoteObject(orphan, newUniqueID, inAdoption: true);
LazyBehaviours.AddDependent(parent, orphanID);
_promotedOrphans.Add(orphan);
return(true);
}
return(false);
}
public void SaveSurrogate(StateObjectSurrogate surrogate)
{
//Save surrogate header
var surrogateContext = StateManager.Current.surrogateManager.GetSurrogateContext(surrogate.UniqueID, surrogate);
var raw = SurrogatesDirectory.ObjectToRaw(surrogate, surrogateContext);
SaveRaw(surrogate.UniqueID, raw);
//Save surrogate value
var uid = UniqueIDGenerator.GetRelativeUniqueID(surrogate, StateObjectSurrogate.VALUE_PREFIX);
surrogateContext = StateManager.Current.surrogateManager.GetSurrogateContext(uid, surrogate.Value);
raw = SurrogatesDirectory.ObjectToRaw(surrogate.Value, surrogateContext);
SaveRaw(uid, raw);
}
public void SaveSurrogate(StateObjectSurrogate surrogate)
{
//Saving surrogate header
var surrogatecontext = _surrogateManager.GetSurrogateContext(surrogate.UniqueID, surrogate);
var raw = SurrogatesDirectory.ObjectToRaw(surrogate, surrogatecontext);
SaveRaw(surrogate.UniqueID, raw);
//Saving surrogateValue
if (surrogate.ShouldSerializeValue)
{
var uid = UniqueIDGenerator.GetRelativeUniqueID(surrogate, StateObjectSurrogate.VALUE_PREFIX);
surrogatecontext = _surrogateManager.GetSurrogateContext(uid, surrogate.Value);
raw = SurrogatesDirectory.ObjectToRaw(surrogate.Value, surrogatecontext);
SaveRaw(uid, raw);
}
}
/// <summary>
/// Gets All the ReferencesTables in _cache.
/// </summary>
/// <param name="uniqueID"></param>
/// <returns></returns>
private List <ReferencesTable> GetChildrenReferencesTablesInCache(string uniqueID)
{
HashSet <string> children = children = _stateManager.GetAllChildrenKeys(uniqueID);
List <ReferencesTable> result = null;
foreach (var child in children)
{
result = result ?? new List <ReferencesTable>();
if (UniqueIDGenerator.IsRefencesTable(child) && !_stateManager.IsInElementsToRemove(child))
{
var table = _stateManager.GetObject(child) as ReferencesTable;
result.Add(table);
}
}
return(result);
}
/// <summary>
/// Gets All the ReferencesTables in _tempCache.
/// </summary>
/// <param name="uniqueID"></param>
/// <returns></returns>
private List <ReferencesTable> GetChildrenReferencesTablesInTempStorage(string uniqueID)
{
var children = _stateManager._tempcache.GetAllDependentItems(uniqueID);
List <ReferencesTable> result = null;
foreach (var child in children)
{
result = result ?? new List <ReferencesTable>();
if (UniqueIDGenerator.IsRefencesTable(child.Key))
{
var table = child.Value as ReferencesTable;
result.Add(table);
}
}
return(result);
}
private static IStateObject GetCurrentValue(StateManager stateManager, PropertyInfoEx propEx, IStateObject parentInstance, out string valueRelativeUid, bool isNew = false)
{
var propName = GetPropertyName(propEx);
valueRelativeUid = UniqueIDGenerator.GetRelativeUniqueID(parentInstance, propName);
//First Try: Let's get the object from the Storage.
var currentValue = stateManager.GetObject(valueRelativeUid);
if (currentValue == null)
{
var pointerRelativeUid = UniqueIDGenerator.GetPointerRelativeUniqueID(parentInstance, propName);
//Second try: get the Reference if present.
currentValue = stateManager.GetObject(pointerRelativeUid, isNew: isNew);
}
return(currentValue);
}
internal static void ProcessSetterSimpleTypes(PropertyInfoEx propEx, object parentObject, object newObjectValue, bool isNew = false)
{
if (isNew)
{
return;
}
string propName = propEx.prop.Name;
var parentInstance = (IStateObject)parentObject;
var tracker = StateManager.Current.Tracker;
// Delta Tracking of modified property
if (!tracker.IsDirtyModel(parentInstance))
{
tracker.MarkAsModified(parentInstance, propEx.propertyPositionIndex);
}
var stateManager = StateManager.Current;
if (!stateManager.flagInBind)
{
var bindinguid = UniqueIDGenerator.GetRelativeUniqueID(parentInstance, propName + StateManager.BindingKey);
var bindingPointer = StateManager.Current.GetObject(bindinguid) as StateObjectPointer;
if (bindingPointer != null)
{
var bindingSurrogate = bindingPointer.Target as StateObjectSurrogate;
if (bindingSurrogate != null)
{
var binding = bindingSurrogate.Value as DataBinding;
if (binding != null)
{
var dataSource = binding.DataSourceReference;
if (dataSource is StateObjectSurrogate)
{
var surrogate = (StateObjectSurrogate)dataSource;
var surrogateValue = surrogate.Value;
var setter = SurrogatesDirectory.GetPropertySetter(surrogate.Value);
setter(surrogateValue, binding.DataSourceProperty, newObjectValue);
}
else
{
throw new NotImplementedException();
}
}
}
}
}
}
private static void AddOrUpdateReference(PropertyInfoEx propEx, IStateObject parentInstance, object newValueObj, StateObjectPointerReference currentValue = null, bool isNew = false)
{
var stateManager = StateManager.Current;
string propName = GetPropertyName(propEx);
var relativeUid = UniqueIDGenerator.GetPointerRelativeUniqueID(parentInstance, propName);
var reference = currentValue;
if (reference == null)
{
reference = stateManager.GetObject(relativeUid, isNew: isNew) as StateObjectPointerReference;
}
//We need to remove the pointer;
if (reference != null)
{
// We need to remove the Reference to the value if present and if it's not a
//StateObjectPointerReferenceSuperValueBase
if (!(reference is StateObjectPointerReferenceSuperValueBase))
{
stateManager.ReferencesManager.RemoveReference(reference, reference.Target);
}
// Let's check if the existing reference is compatible with the newValue to
//remove it or if the value being set is null as well.
if (newValueObj == null || !reference.IsCompatibleWith(newValueObj))
{
//If the Reference is not compatible then we need to remove it to get a new one.
stateManager.RemoveObject(relativeUid, true);
reference = null;
}
}
//Only if the newValue is not null we need a reference, otherwise lets avoid the overhead.
if (newValueObj != null && reference == null)
{
//Gets the reference for the property.
reference = GetReference(propEx, parentInstance, newValueObj);
}
//No reference, no value...We don't need to do anything else.
else if (newValueObj == null && reference == null)
{
return;
}
//Once we got the Reference let's update it.
UpdateReferenceValue(stateManager, reference, parentInstance, newValueObj);
}
/// <summary>
/// NOTE: this method is called *ONLY* if the object DOES not come from storage
/// </summary>
/// <param name="obj"></param>
/// <param name="parameters"></param>
/// <param name="t"></param>
/// <param name="isRecovedFromStorage"></param>
private static void InitializeObject(StateManager stateManager, IIocContainer container, IStateObject obj, object[] parameters, Type t, IIocContainerFlags flags)
{
if ((flags & IIocContainerFlags.IsSinglenton) == IIocContainerFlags.IsSinglenton)
{
//Unique ID
obj.UniqueID = UniqueIDGenerator.GetSinglentonUniqueId(t);
}
else
{
//If it doesn't come from storage we must setup the UniqueID
//that will be use later on for persistance
if (!StateManager.IsRootLevelObject(obj))
{
obj.UniqueID = stateManager.UniqueIDGenerator.GetUniqueIDForTemporaryObject();
//A new temparary object was created and it's in resolution.
stateManager.AddIDInResolution(obj.UniqueID);
}
else
{
if (obj is IModel)
{
obj.UniqueID = stateManager.UniqueIDGenerator.GetUniqueIDForModel();
}
else
{
obj.UniqueID = stateManager.UniqueIDGenerator.GetUniqueID();
}
}
}
stateManager.AddNewObject(obj);
if (obj is IDependentViewModel && (flags & IIocContainerFlags.NoBuild) != IIocContainerFlags.NoBuild)
{
try
{
ViewManager.Instance.Events.Suspend();
((IDependentViewModel)obj).Build(container);
}
finally
{
ViewManager.Instance.Events.Resume();
}
/* IDependants are now iLogic so this properties are injected in ILogic resolve code */
}
}
public void UnSubscribe(string eventId, IStateObject source, string methodName)
{
eventId = eventId.ToUpper();
var promisesInfo = HasSubscribers(eventId, source) as PromisesInfo;
if (promisesInfo != null)
{
methodName = methodName.ToUpper();
promisesInfo.Remove(methodName);
var eventSubscriptionId = UniqueIDGenerator.GetEventRelativeUniqueID(source, methodName + eventId);
_stateManager.RemoveObject(eventSubscriptionId, true);
if (promisesInfo.IsEmpty())
{
eventSubscriptionId = UniqueIDGenerator.GetEventRelativeUniqueID(source, eventId);
_stateManager.RemoveObject(eventSubscriptionId, true);
}
}
}
