public TValue this[TKey key] { get { var entry = internalDictCase2[key]; return((TValue)entry.Target); } set { //Was there a value CollectionStateObjectReference oldCollectionReference; if (internalDictCase2.TryGetValue(key, out oldCollectionReference)) { if (!oldCollectionReference.IsNull) { _referencesManager.UnSubscribe(_parent, oldCollectionReference.TargetUniqueID); } } //Now we can assign the new value internalDictCase2[key] = new CollectionStateObjectReference((IStateObject)value); var stateObject = (IStateObject)value; if (stateObject != null) { if (!_stateManager.IsStateObjectAllAttached(stateObject)) { _stateManager.RegisterPossibleOrphan(_parent, stateObject); } _referencesManager.Subscribe(_parent, stateObject); } } }
private object ReadInputAsStateObject() { object val = reader.Value; reader.Read(); string value = (string)val; var refe = new CollectionStateObjectReference(value); return(refe); }
/// <summary> /// Removing the reference from the surrogate. /// </summary> /// <param name="internalValue"></param> private void RemoveReferenceFromStateObjectSurrogate(CollectionStateObjectReference internalValue) { var obj = internalValue.Target as IPromise; if (obj != null) { var surrogate = DictionaryUtils.GetObjectContainingMethod(obj) as IStateObjectSurrogate; if (surrogate != null) { surrogateManager.RemoveSurrogateReference(surrogate, (IStateObject)obj); } } }
public TValue this [TKey key] { get { var internalValue = internalDictCase4 [new CollectionStateObjectReference((IStateObject)key)]; if (internalValue.IsNull != null) { return((TValue)internalValue.Target); } return(default(TValue)); } set { internalDictCase4 [new CollectionStateObjectReference((IStateObject)key)] = new CollectionStateObjectReference((IStateObject)value); } }
public void UpdateReference(string oldUniqueID, string newUniqueID) { TKey key = default(TKey); bool found = false; foreach (var pair in internalDictCase2) { if (pair.Value.TargetUniqueID == oldUniqueID) { key = pair.Key; found = true; break; } } if (found) { internalDictCase2[key] = new CollectionStateObjectReference(newUniqueID); } }
public TValue this[TKey key] { get { var entry = internalDictCase6[key]; var surrogate = entry.Target as IStateObjectSurrogate; if (surrogate != null) { return((TValue)surrogate.Value); } return(default(TValue)); } set { CollectionStateObjectReference valueRef; if (internalDictCase6.TryGetValue(key, out valueRef) /*&& valueRef!=null*/) { if (!valueRef.IsNull /* != NullCollectionStateObjectReference.CommonInstance*/) { referencesManager.UnSubscribe(valueObject: _parent, UniqueID: valueRef.Target.UniqueID); } } var surrogate = surrogateManager.GetStateObjectSurrogate(value, true); //TODO: There is a risk of having the UniqueId become invalid. surrogateManager.AddSurrogateReference(surrogate, _parent); internalDictCase6[key] = new CollectionStateObjectReference((IStateObject)surrogate); var stateObject = (IStateObject)surrogate; //Possible orphan if (stateObject != null) { if (!_stateManager.IsStateObjectAllAttached(stateObject)) { _stateManager.RegisterPossibleOrphan(_parent, stateObject); } referencesManager.Subscribe(_parent, stateObject); } } }
/// <summary> /// Updates all the Targets of the References to match the new value. /// </summary> /// <param name="uniqueID"></param> public void UpdateReferencesTable(string oldParent, string newParent, string oldUniqueID, string newUniqueID) { for (int i = References.Count - 1; i >= 0 && References.Count > 0; i--) { var reference = References[i]; if (reference.TargetUniqueID.Contains(oldParent)) { References[i] = new CollectionStateObjectReference(UniqueIDGenerator.ReplaceParent(reference.TargetUniqueID, oldParent, newParent)); } else if (reference.Target == null) { lock (_referencesLock) { References.RemoveAt(i); MarkAsDirty(); } } else if (reference.Target is StateObjectPointerReference) { ((StateObjectPointerReference)reference.Target).Target = ReferencedObject; StateManager.Current.MarkAsDirty((StateObjectPointerReference)reference.Target, "Target"); } else if (reference.Target is IReferenceWatcher) { ((IReferenceWatcher)reference.Target).UpdateReference(oldUniqueID, newUniqueID); } else if (reference.Target is Page //When a List's UniqueID has been switched, we have to notify the Page's Parent property, //which hold the List's UniqueID, and updates the List's uniqueID ) { var parent = StateManager.Current.GetObject(newParent); if (parent is IVirtualListSerializable) { //Update the Parent property, which is the List's uniqueID ((Page)reference.Target).Parent = parent; StateManager.Current.MarkAsDirty(((Page)reference.Target), "Parent"); } } } }
public TValue this [TKey key] { get { var entry5 = internalDictCase5[key]; TValue retEntry5 = (TValue)DictionaryUtils.RetrieveDelegateFromPromise(typeof(TValue), (IPromise)entry5.Target); return(retEntry5); } set { //Erase old reference CollectionStateObjectReference internalValue; if (internalDictCase5.TryGetValue(key, out internalValue) /*&& internalValue !=null*/) { if (!internalValue.IsNull) { stateManager.RemoveObject(internalValue.TargetUniqueID, mustDetach: true, deep: true); RemoveReferenceFromStateObjectSurrogate(internalValue); } } //This is multicast delegate create contiuation var val = DictionaryUtils.CreatePromise(stateManager, ((Delegate)(object)value)); internalDictCase5 [key] = new CollectionStateObjectReference((IStateObject)val); AddReferenceIntoStateObjectSurrogate(val); } }