public static void CallCacheModificationActive(ICacheModification cacheModification, bool oldValue, bool newValue) { if (!oldValue) { cacheModification.Active = newValue; } }
public static void CallCacheModificationInternalUpdate(ICacheModification cacheModification, bool oldValue, bool newValue) { if (!oldValue) { cacheModification.InternalUpdate = newValue; } }
protected void ChangeFirstLevelCaches(CacheDependencyNode node, ISet <IObjRef> intermediateDeletes) { List <IDataChangeEntry> deletes = new List <IDataChangeEntry>(); ICacheModification cacheModification = this.CacheModification; bool oldCacheModificationValue = cacheModification.Active; if (!oldCacheModificationValue) { cacheModification.Active = true; } try { ChangeFirstLevelCachesIntern(node, intermediateDeletes); } finally { if (!oldCacheModificationValue) { cacheModification.Active = oldCacheModificationValue; } } if (deletes.Count > 0) { IDataChange dce = DataChangeEvent.Create(0, 0, deletes.Count); ListUtil.AddAll(dce.Deletes, dce.Deletes.Count, deletes); GuiThreadHelper.InvokeOutOfGui(delegate() { EventDispatcher.DispatchEvent(dce); }); } }
public void FirePropertyChange(INotifyPropertyChangedSource obj, PropertyChangeSupport propertyChangeSupport, IPropertyInfo property, Object oldValue, Object currentValue) { ICacheModification cacheModification = this.CacheModification; PropertyEntry entry = GetPropertyEntry(obj.GetType(), property); if (currentValue == null) { currentValue = entry.getDelegate(obj); } try { if (entry.isAddedRemovedCheckNecessary) { if (oldValue != null) { HandleRemovedItem(obj, oldValue, entry.isParentChildSetter); } if (currentValue != null) { HandleAddedItem(obj, currentValue, entry.isParentChildSetter); } } String[] propertyNames = entry.propertyNames; Object[] oldValues; Object[] currentValues; if (FireOldPropertyValueActive) { oldValues = CreateArrayOfValues(oldValue, propertyNames.Length); currentValues = Object.ReferenceEquals(currentValue, oldValue) ? oldValues : CreateArrayOfValues(currentValue, propertyNames.Length); } else { oldValues = entry.unknownValues; currentValues = oldValues; } FirePropertyChange(obj, entry.pceArgs, propertyNames, oldValues, currentValues); if (entry.firesToBeCreatedPCE) { IDataObject dObj = (IDataObject)obj; if (dObj.ToBeCreated && dObj.ToBeUpdated) { dObj.ToBeUpdated = false; } } } finally { if (entry.doesModifyToBeUpdated && !cacheModification.ActiveOrFlushingOrInternalUpdate) { SetToBeUpdated(obj, true); } } }
public void FirePropertyChange(INotifyPropertyChangedSource obj, PropertyChangedEventArgs[] evnts, String[] propertyNames, Object[] oldValues, Object[] currentValues) { PropertyChangeSupport propertyChangeSupport = obj.PropertyChangeSupport; IList <IPropertyChangeExtension> extensions = propertyChangeExtensions.GetExtensions(obj.GetType()); if (propertyChangeSupport == null && extensions == null && !(obj is IPropertyChangedEventHandler)) { return; } ICacheModification cacheModification = this.CacheModification; if (cacheModification.Active) { cacheModification.QueuePropertyChangeEvent(delegate() { ExecuteFirePropertyChange(propertyChangeSupport, extensions, obj, evnts, propertyNames, oldValues, currentValues); }); return; } ExecuteFirePropertyChange(propertyChangeSupport, extensions, obj, evnts, propertyNames, oldValues, currentValues); }
public void HandleCollectionChange(INotifyPropertyChangedSource obj, Object sender, NotifyCollectionChangedEventArgs evnt) { IEntityMetaData metaData = ((IEntityMetaDataHolder)obj).Get__EntityMetaData(); Object bases = null; bool parentChildProperty = false; RelationMember[] relationMembers = metaData.RelationMembers; for (int relationIndex = relationMembers.Length; relationIndex-- > 0;) { Object valueDirect = ((IValueHolderContainer)obj).Get__ValueDirect(relationIndex); if (!Object.ReferenceEquals(valueDirect, sender)) { continue; } if (relationMembers[relationIndex].GetAnnotation(typeof(ParentChild)) != null) { bases = obj; parentChildProperty = true; } else { bases = sender; } break; } if (bases == null) { foreach (PrimitiveMember primitiveMember in metaData.PrimitiveMembers) { Object valueDirect = primitiveMember.GetValue(obj); if (!Object.ReferenceEquals(valueDirect, sender)) { continue; } bases = obj; parentChildProperty = true; break; } } if (bases == null) { throw new Exception("Must never happen"); } ICacheModification cacheModification = this.CacheModification; bool oldCacheModification = cacheModification.Active; bool cacheModificationUsed = false; try { switch (evnt.Action) { case NotifyCollectionChangedAction.Add: case NotifyCollectionChangedAction.Remove: case NotifyCollectionChangedAction.Replace: if (evnt.OldItems != null) { foreach (Object oldItem in evnt.OldItems) { HandleRemovedItem(obj, oldItem, parentChildProperty); } } if (evnt.NewItems != null) { foreach (Object newItem in evnt.NewItems) { HandleAddedItem(obj, newItem, parentChildProperty); } } break; #if !SILVERLIGHT case NotifyCollectionChangedAction.Move: // Nothing to do in that case break; #endif case NotifyCollectionChangedAction.Reset: throw new NotSupportedException("Reset is not allowed in a managed collection"); default: throw RuntimeExceptionUtil.CreateEnumNotSupportedException(evnt.Action); } IList <ICollectionChangeExtension> extensions = collectionChangeExtensions.GetExtensions(obj.GetType()); for (int a = 0, size = extensions.Count; a < size; a++) { extensions[a].CollectionChanged(obj, evnt); } } finally { if (!oldCacheModification) { SetToBeUpdated(obj, true); } if (cacheModificationUsed) { cacheModification.Active = oldCacheModification; } } }
protected void ApplyChangesToOriginalsIntern(ICUDResult cudResult, IOriCollection oriCollection, ICache cache) { ICacheModification cacheModification = this.CacheModification; IConversionHelper conversionHelper = this.ConversionHelper; IEntityMetaDataProvider entityMetaDataProvider = this.EntityMetaDataProvider; IList <Object> originalRefs = cudResult.GetOriginalRefs(); IList <IObjRef> allChangeORIs = oriCollection.AllChangeORIs; String[] allChangedBy = oriCollection.AllChangedBy; long[] allChangedOn = oriCollection.AllChangedOn; String singleChangedBy = oriCollection.ChangedBy; long? singleChangedOn = oriCollection.ChangedOn; bool newInstanceOnCall = CacheProvider.IsNewInstanceOnCall; IList <Object> validObjects = new List <Object>(originalRefs.Count); bool oldCacheModificationValue = CacheModification.Active; CacheModification.Active = true; try { for (int a = originalRefs.Count; a-- > 0;) { Object originalRef = originalRefs[a]; IObjRef ori = allChangeORIs[a]; if (originalRef == null) { // Object has been deleted by cascade delete contraints on server merge or simply a "not specified" original ref continue; } if (originalRef is IObjRef) { continue; } long? changedOn = allChangedOn != null ? allChangedOn[a] : singleChangedOn; String changedBy = allChangedBy != null ? allChangedBy[a] : singleChangedBy; IEntityMetaData metaData = ((IEntityMetaDataHolder)originalRef).Get__EntityMetaData(); PrimitiveMember versionMember = metaData.VersionMember; PrimitiveMember keyMember = metaData.IdMember; PrimitiveMember onMember, byMember; if (keyMember.GetValue(originalRef, false) == null) { onMember = metaData.CreatedOnMember; byMember = metaData.CreatedByMember; } else { onMember = metaData.UpdatedOnMember; byMember = metaData.UpdatedByMember; } if (onMember != null && changedOn != null) { Object createdOn = ConversionHelper.ConvertValueToType(onMember.ElementType, changedOn); onMember.SetValue(originalRef, createdOn); } if (byMember != null && changedBy != null) { Object createdBy = ConversionHelper.ConvertValueToType(byMember.ElementType, changedBy); byMember.SetValue(originalRef, createdBy); } if (ori == null) { keyMember.SetValue(originalRef, null); if (versionMember != null) { versionMember.SetValue(originalRef, null); } if (originalRef is IDataObject) { ((IDataObject)originalRef).ToBeUpdated = false; ((IDataObject)originalRef).ToBeDeleted = false; } continue; // Object has been deleted directly } keyMember.SetValue(originalRef, ConversionHelper.ConvertValueToType(keyMember.RealType, ori.Id)); if (versionMember != null) { if (AlwaysUpdateVersionInChangedEntities) { versionMember.SetValue(originalRef, ConversionHelper.ConvertValueToType(versionMember.RealType, ori.Version)); } else { // We INTENTIONALLY do NOT set the version and let it on its old value, to force the following DCE to refresh the cached object with 'real' data // If we set the version here to the ori.getVersion(), the DCE will 'see' a already valid object - but is IS NOT valid // because it may not contain bi-directional information which can only be resolved by reloading the object from persistence layer //versionMember.SetValue(originalRef, null); } } if (originalRef is IDataObject) { ((IDataObject)originalRef).ToBeUpdated = false; ((IDataObject)originalRef).ToBeDeleted = false; } validObjects.Add(originalRef); } PutInstancesToCurrentCache(validObjects, cache); } finally { CacheModification.Active = oldCacheModificationValue; } }
protected void ProcessPendingOrelsAndObjRefs(ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchPath, AlreadyHandledSet alreadyHandledSet, IdentityLinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisLoadedHistory, IdentityLinkedMap <ICacheIntern, IISet <IObjRelation> > cacheToOrelsLoadedHistory, IdentityLinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisToLoad, IdentityLinkedMap <ICacheIntern, IMap <IObjRelation, bool> > cacheToOrelsToLoad, List <PrefetchCommand> pendingPrefetchCommands, List <Object> hardRefList) { // all relation members where at least one instance of the owning entity type needs a prefetch on this member in the immediate next step MergePrefetchPathsCache mergePrefetchPathsCache = new MergePrefetchPathsCache(EntityMetaDataProvider); IdentityLinkedSet <Member> prioMembers = PrioMembersProvider.GetPrioMembers(entityTypeToPrefetchPath, pendingPrefetchCommands, mergePrefetchPathsCache); LoadAndAddOrels(cacheToOrelsToLoad, hardRefList, cacheToOrelsLoadedHistory, cacheToOrisToLoad, prioMembers); LoadAndAddOris(cacheToOrisToLoad, hardRefList, cacheToOrisLoadedHistory); while (pendingPrefetchCommands.Count > 0) { PrefetchCommand[] currentPrefetchCommands = pendingPrefetchCommands.ToArray(); // Clear the items to be ready for cascaded items in new batch recursion step pendingPrefetchCommands.Clear(); if (prioMembers.Count > 0) { for (int a = 0, size = currentPrefetchCommands.Length; a < size; a++) { PrefetchCommand prefetchCommand = currentPrefetchCommands[a]; DirectValueHolderRef valueHolder = prefetchCommand.valueHolder; if (!prioMembers.Contains(valueHolder.Member)) { currentPrefetchCommands[a] = null; pendingPrefetchCommands.Add(prefetchCommand); } } } GuiThreadHelper.InvokeInGuiAndWait(delegate() { ICacheModification cacheModification = CacheModification; ValueHolderContainerMixin valueHolderContainerMixin = ValueHolderContainerMixin; bool oldActive = cacheModification.Active; if (!oldActive) { cacheModification.Active = true; } try { foreach (PrefetchCommand prefetchCommand in currentPrefetchCommands) { if (prefetchCommand == null) { continue; } DirectValueHolderRef valueHolder = prefetchCommand.valueHolder; PrefetchPath[] cachePaths = prefetchCommand.prefetchPaths; RelationMember member = valueHolder.Member; // Merge the root prefetch path with the relative prefetch path cachePaths = mergePrefetchPathsCache.MergePrefetchPaths(member.ElementType, cachePaths, entityTypeToPrefetchPath); IObjRefContainer vhc = valueHolder.Vhc; ICacheIntern targetCache; bool doSetValue = false; if (valueHolder is IndirectValueHolderRef) { IndirectValueHolderRef valueHolderKey = (IndirectValueHolderRef)valueHolder; targetCache = valueHolderKey.RootCache; } else { targetCache = ((IValueHolderContainer)vhc).__TargetCache; doSetValue = true; } int relationIndex = vhc.Get__EntityMetaData().GetIndexByRelation(member); IObjRef[] objRefs = vhc.Get__ObjRefs(relationIndex); Object obj = valueHolderContainerMixin.GetValue(vhc, relationIndex, member, targetCache, objRefs, CacheDirective.FailEarly); if (doSetValue && obj != null) { member.SetValue(vhc, obj); } EnsureInitializedRelationsIntern3(obj, cachePaths, entityTypeToPrefetchPath, cacheToOrisToLoad, cacheToOrelsToLoad, cacheToOrisLoadedHistory, cacheToOrelsLoadedHistory, alreadyHandledSet, pendingPrefetchCommands); } } finally { if (!oldActive) { cacheModification.Active = false; } } }); // Remove all oris which have already been tried to load before if (cacheToOrisToLoad.Count == 0 && cacheToOrelsToLoad.Count == 0 && pendingPrefetchCommands.Count == 0) { return; } prioMembers = PrioMembersProvider.GetPrioMembers(entityTypeToPrefetchPath, pendingPrefetchCommands, mergePrefetchPathsCache); LoadAndAddOrels(cacheToOrelsToLoad, hardRefList, cacheToOrelsLoadedHistory, cacheToOrisToLoad, prioMembers); LoadAndAddOris(cacheToOrisToLoad, hardRefList, cacheToOrisLoadedHistory); } }
public void Initialize(ICacheModification cacheModification, IEntityFactory entityFactory) { this.cacheModification = cacheModification; this.entityFactory = entityFactory; if (AlternateIdMemberIndicesInPrimitives == null) { AlternateIdMemberIndicesInPrimitives = EmptyShortArray; } if (PrimitiveMembers == null) { PrimitiveMembers = EmptyPrimitiveMembers; } else { // Array.Sort<INamed>(PrimitiveMembers, namedItemComparer); } List <PrimitiveMember> primitiveToManyMembers = new List <PrimitiveMember>(); foreach (PrimitiveMember primitiveMember in PrimitiveMembers) { if (primitiveMember.IsToMany) { primitiveToManyMembers.Add(primitiveMember); } } this.primitiveToManyMembers = primitiveToManyMembers.ToArray(); if (RelationMembers == null) { RelationMembers = EmptyRelationMembers; } else { // Array.Sort<INamed>(RelationMembers, namedItemComparer); } if (AlternateIdMembers == null) { AlternateIdMembers = EmptyPrimitiveMembers; } else { // Array.Sort<INamed>(AlternateIdMembers, namedItemComparer); } nameToMemberDict.Clear(); relMemberToIndexDict.Clear(); relMemberNameToIndexDict.Clear(); primMemberToIndexDict.Clear(); primMemberNameToIndexDict.Clear(); if (IdMember != null) { PrimitiveMember idMember = IdMember; nameToMemberDict.Add(idMember.Name, idMember); if (idMember is CompositeIdMember) { foreach (PrimitiveMember member in ((CompositeIdMember)idMember).Members) { nameToMemberDict.Add(member.Name, member); } } } if (VersionMember != null) { nameToMemberDict.Add(VersionMember.Name, VersionMember); } for (int a = PrimitiveMembers.Length; a-- > 0;) { Member member = PrimitiveMembers[a]; nameToMemberDict.Add(member.Name, member); primMemberNameToIndexDict.Add(member.Name, a); primMemberToIndexDict.Add(member, a); if (Object.ReferenceEquals(member, IdMember) || Object.ReferenceEquals(member, VersionMember) || Object.ReferenceEquals(member, UpdatedByMember) || Object.ReferenceEquals(member, UpdatedOnMember) || Object.ReferenceEquals(member, CreatedByMember) || Object.ReferenceEquals(member, CreatedOnMember)) { // technical members must never be merge relevant SetMergeRelevant(member, false); } } for (int a = RelationMembers.Length; a-- > 0;) { RelationMember member = RelationMembers[a]; nameToMemberDict.Add(member.Name, member); relMemberNameToIndexDict.Add(member.Name, a); relMemberToIndexDict.Add(member, a); } memberNameToIdIndexDict.Clear(); if (IdMember != null) { memberNameToIdIndexDict.Add(IdMember.Name, ObjRef.PRIMARY_KEY_INDEX); } AlternateIdMemberIndicesInPrimitives = new int[AlternateIdMembers.Length][]; for (int idIndex = AlternateIdMembers.Length; idIndex-- > 0;) { int[] compositeIndex = null; Member alternateIdMember = AlternateIdMembers[idIndex]; Member[] memberItems; if (alternateIdMember is CompositeIdMember) { memberItems = ((CompositeIdMember)alternateIdMember).Members; } else { memberItems = new Member[] { alternateIdMember }; } compositeIndex = new int[memberItems.Length]; for (int compositePosition = compositeIndex.Length; compositePosition-- > 0;) { compositeIndex[compositePosition] = -1; Member memberItem = memberItems[compositePosition]; for (int primitiveIndex = PrimitiveMembers.Length; primitiveIndex-- > 0;) { if (memberItem.Equals(PrimitiveMembers[primitiveIndex])) { compositeIndex[compositePosition] = primitiveIndex; break; } } if (compositeIndex[compositePosition] == -1) { throw new Exception("AlternateId is not a primitive: " + memberItem); } } AlternateIdMemberIndicesInPrimitives[idIndex] = compositeIndex; memberNameToIdIndexDict.Add(alternateIdMember.Name, (sbyte)idIndex); } if (TypesRelatingToThis != null && TypesRelatingToThis.Length > 0) { for (int i = TypesRelatingToThis.Length; i-- > 0;) { typesRelatingToThisSet.Add(TypesRelatingToThis[i]); } } if (CreatedByMember != null) { ChangeInterningBehavior(CreatedByMember, true); } if (UpdatedByMember != null) { ChangeInterningBehavior(UpdatedByMember, true); } SetTechnicalMember(IdMember); SetTechnicalMember(VersionMember); SetTechnicalMember(CreatedByMember); SetTechnicalMember(CreatedOnMember); SetTechnicalMember(UpdatedByMember); SetTechnicalMember(UpdatedOnMember); }