protected bool IsPrio2Member(IEntityMetaData rootMetaData, IEntityMetaData metaData, PrefetchPath[] prefetchPaths,
ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchSteps, Tuple2KeyHashMap <Type, PrefetchPath[], bool?> alreadyVisited,
MergePrefetchPathsCache mergePrefetchPathsCache)
{
IEntityMetaDataProvider entityMetaDataProvider = this.entityMetaDataProvider;
foreach (PrefetchPath prefetchPath in prefetchPaths)
{
if (!alreadyVisited.PutIfNotExists(prefetchPath.memberType, prefetchPath.children, true))
{
continue;
}
PrefetchPath[] children = mergePrefetchPathsCache.MergePrefetchPaths(prefetchPath.memberType, prefetchPath.children, entityTypeToPrefetchSteps);
if (children == null)
{
continue;
}
IEntityMetaData childMetaData = entityMetaDataProvider.GetMetaData(prefetchPath.memberType);
if (metaData == childMetaData)
{
// prio1 case at a later stage
continue;
}
if (rootMetaData == childMetaData)
{
// prio1 in a transitive manner (current stage)
return(true);
}
if (IsPrio2Member(rootMetaData, childMetaData, children, entityTypeToPrefetchSteps, alreadyVisited, mergePrefetchPathsCache))
{
return(true);
}
}
return(false);
}
public static object GetIdValue(this object entity, IEntityMetaDataProvider provider)
{
if (null == entity)
throw new ArgumentNullException("entity");
return provider.CreateEntityMetaData().GetPrimaryKey().Property.GetValue(entity);
}
public FromEntityMetaDataProviderTableReader(IEntityMetaDataProvider provider)
{
if (null == provider)
throw new ArgumentNullException("provider");
this.metaData = provider.CreateEntityMetaData();
}
public static void SetIdValue(this object entity, IEntityMetaDataProvider provider, object value)
{
if (null == entity)
throw new ArgumentNullException("entity");
provider.CreateEntityMetaData().GetPrimaryKey().Property.SetValueSafely(entity, value);
}
public MakeSequenceIdentityMetaDataProvider(IEntityMetaDataProvider concrete)
{
if (null == concrete)
throw new ArgumentNullException(nameof(concrete));
this.concrete = concrete;
}
public EntityMetaDataMemberVisitor(IClassVisitor cv, Type declaringType, Type entityType, String memberName, IEntityMetaDataProvider entityMetaDataProvider, IPropertyInfo[] propertyPath)
: base(cv)
{
this.declaringType = declaringType;
this.entityType = entityType;
this.memberName = memberName;
this.entityMetaDataProvider = entityMetaDataProvider;
this.propertyPath = propertyPath;
}
/// <summary>构造函数</summary>
public EntityMetaDataService()
{
// 创建对象构建器(Spring.NET)
string springObjectFile = EntitiesConfigurationView.Instance.Configuration.Keys["SpringObjectFile"].Value;
SpringObjectBuilder objectBuilder = SpringObjectBuilder.Create(EntitiesConfiguration.ApplicationName, springObjectFile);
// 创建数据提供器
provider = objectBuilder.GetObject <IEntityMetaDataProvider>(typeof(IEntityMetaDataProvider));
}
protected IPrefetchState EnsureInitializedRelationsIntern2(Object objects, ILinkedMap <Type, PrefetchPath[]> entityTypeToPrefetchPath)
{
bool setCreated = false;
try
{
AlreadyHandledSet alreadyHandledSet = alreadyHandledSetTL.Value;
if (alreadyHandledSet == null)
{
alreadyHandledSet = new AlreadyHandledSet();
alreadyHandledSetTL.Value = alreadyHandledSet;
setCreated = true;
}
IEntityMetaDataProvider entityMetaDataProvider = this.EntityMetaDataProvider;
ValueHolderContainerMixin valueHolderContainerMixin = this.ValueHolderContainerMixin;
IdentityLinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisLoadedHistory = new IdentityLinkedMap <ICacheIntern, IISet <IObjRef> >();
IdentityLinkedMap <ICacheIntern, IISet <IObjRelation> > cacheToOrelsLoadedHistory = new IdentityLinkedMap <ICacheIntern, IISet <IObjRelation> >();
IdentityLinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisToLoad = new IdentityLinkedMap <ICacheIntern, IISet <IObjRef> >();
IdentityLinkedMap <ICacheIntern, IMap <IObjRelation, bool> > cacheToOrelsToLoad = new IdentityLinkedMap <ICacheIntern, IMap <IObjRelation, bool> >();
List <PrefetchCommand> loadItems = new List <PrefetchCommand>();
HandleObjects(objects, entityTypeToPrefetchPath, alreadyHandledSet, cacheToOrisLoadedHistory, cacheToOrelsLoadedHistory, cacheToOrisToLoad,
cacheToOrelsToLoad, loadItems);
// Remove all oris which have already been tried to load before
if (cacheToOrisToLoad.Count == 0 && cacheToOrelsToLoad.Count == 0)
{
// No ori remaining which makes sense to try to load
if (setCreated)
{
return(new PrefetchState(alreadyHandledSet));
}
return(null);
}
List <Object> hardRefList = new List <Object>();
// Store hard-ref-list to global hard ref
alreadyHandledSet.Put(hardRefList, null, true);
ProcessPendingOrelsAndObjRefs(entityTypeToPrefetchPath, alreadyHandledSet, cacheToOrisLoadedHistory, cacheToOrelsLoadedHistory, cacheToOrisToLoad,
cacheToOrelsToLoad, loadItems, hardRefList);
// No ori remaining which makes sense to try to load
if (setCreated)
{
return(new PrefetchState(alreadyHandledSet));
}
return(null);
}
finally
{
if (setCreated)
{
alreadyHandledSetTL.Value = null;
}
}
}
public Binding(object entity, IEntityMetaDataProvider provider, IEnumerable<IEntityControl> entityControls)
{
if (null == entity)
throw new ArgumentNullException("Binding.Entity");
if (null == provider)
throw new ArgumentNullException("Binding.EntityMetaDataProvider");
if (entityControls.IsEmptyList())
throw new ArgumentNullException("Binding.EntityControls");
this.entity = entity;
this.provider = provider;
this.entityControls = new ReadOnlyCollection<IEntityControl>(entityControls.ToList());
}
public CUDResultDiff(ICUDResult left, ICUDResult right, bool doFullDiff, ICUDResultHelper cudResultHelper, IEntityMetaDataProvider entityMetaDataProvider)
{
this.doFullDiff = doFullDiff;
this.left = left;
this.right = right;
this.cudResultHelper = cudResultHelper;
this.entityMetaDataProvider = entityMetaDataProvider;
if (doFullDiff)
{
diffChanges = new List <IChangeContainer>();
originalRefs = new List <Object>();
}
else
{
diffChanges = EmptyList.Empty <IChangeContainer>();
originalRefs = EmptyList.Empty <Object>();
}
}
public MergePrefetchPathsCache(IEntityMetaDataProvider entityMetaDataProvider)
{
this.entityMetaDataProvider = entityMetaDataProvider;
}
public ICUDResult CreateCUDResult(MergeHandle mergeHandle)
{
ILinkedMap <Type, ICUDResultExtension> typeToCudResultExtension = extensions.GetExtensions();
foreach (Entry <Type, ICUDResultExtension> entry in typeToCudResultExtension)
{
entry.Value.Extend(mergeHandle);
}
IdentityLinkedMap <Object, IList <IUpdateItem> > objToModDict = mergeHandle.objToModDict;
IdentityHashSet <Object> objToDeleteSet = mergeHandle.objToDeleteSet;
HashMap <Type, IPrimitiveUpdateItem[]> entityTypeToFullPuis = new HashMap <Type, IPrimitiveUpdateItem[]>();
HashMap <Type, IRelationUpdateItem[]> entityTypeToFullRuis = new HashMap <Type, IRelationUpdateItem[]>();
List <IChangeContainer> allChanges = new List <IChangeContainer>(objToModDict.Count);
List <Object> originalRefs = new List <Object>(objToModDict.Count);
foreach (Object objToDelete in objToDeleteSet)
{
IObjRef ori = OriHelper.GetCreateObjRef(objToDelete, mergeHandle);
DeleteContainer deleteContainer = new DeleteContainer();
deleteContainer.Reference = ori;
allChanges.Add(deleteContainer);
originalRefs.Add(objToDelete);
}
IEntityMetaDataProvider entityMetaDataProvider = this.EntityMetaDataProvider;
foreach (Entry <Object, IList <IUpdateItem> > entry in objToModDict)
{
Object obj = entry.Key;
IList <IUpdateItem> modItems = entry.Value;
IEntityMetaData metaData = entityMetaDataProvider.GetMetaData(obj.GetType());
IPrimitiveUpdateItem[] fullPuis = GetEnsureFullPUIs(metaData, entityTypeToFullPuis);
IRelationUpdateItem[] fullRuis = GetEnsureFullRUIs(metaData, entityTypeToFullRuis);
int puiCount = 0, ruiCount = 0;
for (int a = modItems.Count; a-- > 0;)
{
IUpdateItem modItem = modItems[a];
Member member = metaData.GetMemberByName(modItem.MemberName);
if (modItem is IRelationUpdateItem)
{
fullRuis[metaData.GetIndexByRelation(member)] = (IRelationUpdateItem)modItem;
ruiCount++;
}
else
{
fullPuis[metaData.GetIndexByPrimitive(member)] = (IPrimitiveUpdateItem)modItem;
puiCount++;
}
}
IRelationUpdateItem[] ruis = CompactRUIs(fullRuis, ruiCount);
IPrimitiveUpdateItem[] puis = CompactPUIs(fullPuis, puiCount);
IObjRef ori = OriHelper.GetCreateObjRef(obj, mergeHandle);
originalRefs.Add(obj);
if (ori is IDirectObjRef)
{
CreateContainer createContainer = new CreateContainer();
((IDirectObjRef)ori).CreateContainerIndex = allChanges.Count;
createContainer.Reference = ori;
createContainer.Primitives = puis;
createContainer.Relations = ruis;
allChanges.Add(createContainer);
}
else
{
UpdateContainer updateContainer = new UpdateContainer();
updateContainer.Reference = ori;
updateContainer.Primitives = puis;
updateContainer.Relations = ruis;
allChanges.Add(updateContainer);
}
}
return(new CUDResult(allChanges, originalRefs));
}
protected override List <IMember> BuildMemberList()
{
List <IMember> list = new List <IMember>();
if (_target == null)
{
return(list);
}
if (Context == null)
{
return(base.BuildMemberList());
}
IEntityMetaDataProvider entityMetaDataProvider = Context.GetService <IEntityMetaDataProvider>();
Type type = _target.GetType();
IEntityMetaData metaData = entityMetaDataProvider.GetMetaData(type, true);
if (metaData == null)
{
return(base.BuildMemberList());
}
HashSet <String> suppressedPropertyNames = new HashSet <String>();
foreach (RelationMember member in metaData.RelationMembers)
{
suppressedPropertyNames.Add(ValueHolderIEC.GetObjRefsFieldName(member.Name));
suppressedPropertyNames.Add(ValueHolderIEC.GetInitializedFieldName(member.Name));
}
HashMap <String, RelationMember> nameToRelationMap = new HashMap <String, RelationMember>();
foreach (RelationMember member in metaData.RelationMembers)
{
nameToRelationMap.Put(member.Name + ValueHolderIEC.GetNoInitSuffix(), member);
}
ITypeInfoItem[] members = Context.GetService <ITypeInfoProvider>().GetTypeInfo(type).Members;
foreach (ITypeInfoItem member in members)
{
if (!member.CanRead)
{
continue;
}
DebuggerBrowsableAttribute att = member.GetAnnotation <DebuggerBrowsableAttribute>();
if (att != null && att.State == DebuggerBrowsableState.Never)
{
continue;
}
String propertyName = member.Name;
if (suppressedPropertyNames.Contains(propertyName))
{
continue;
}
RelationMember relMember = nameToRelationMap.Get(propertyName);
Object value = null;
if (relMember != null)
{
propertyName = relMember.Name;
int relationIndex = metaData.GetIndexByRelationName(propertyName);
ValueHolderState state = ((IObjRefContainer)_target).Get__State(relationIndex);
if (!ValueHolderState.INIT.Equals(state))
{
IObjRef[] objRefs = ((IObjRefContainer)_target).Get__ObjRefs(relationIndex);
if (objRefs == null)
{
list.Add(new LazyUnknownMember(propertyName, state, member.RealType));
}
else
{
list.Add(new LazyMember(propertyName, state, objRefs, member.RealType));
}
continue;
}
}
if (value == null)
{
try
{
value = member.GetValue(_target);
}
catch (Exception ex)
{
value = ex;
}
}
list.Add(new FHPMember(propertyName, value, member.RealType));
}
return(list.OrderBy(m => m.Name).ToList());
}
protected void LoadAndAddOrels(ICacheIntern cache, IMap <IObjRelation, bool> orelsToLoad, IList <Object> hardRefList,
IMap <ICacheIntern, IISet <IObjRelation> > cacheToOrelsLoadedHistory, ILinkedMap <ICacheIntern, IISet <IObjRef> > cacheToOrisToLoad,
IdentityLinkedSet <Member> prioMembers)
{
IList <IObjRelation> objRelList;
if (prioMembers.Count > 0)
{
objRelList = new List <IObjRelation>(orelsToLoad.Count);
IEntityMetaDataProvider entityMetaDataProvider = this.EntityMetaDataProvider;
foreach (Entry <IObjRelation, Boolean> entry in orelsToLoad)
{
IObjRelation objRel = entry.Key;
IEntityMetaData metaData = entityMetaDataProvider.GetMetaData(objRel.RealType);
RelationMember memberByName = (RelationMember)metaData.GetMemberByName(objRel.MemberName);
if (!prioMembers.Contains(memberByName))
{
continue;
}
objRelList.Add(objRel);
}
}
else
{
objRelList = orelsToLoad.KeyList();
}
IList <IObjRelationResult> objRelResults = cache.GetObjRelations(objRelList, cache, CacheDirective.ReturnMisses);
IISet <IObjRef> orisToLoad = null;
for (int a = 0, size = objRelResults.Count; a < size; a++)
{
IObjRelation objRel = objRelList[a];
IObjRelationResult objRelResult = objRelResults[a];
bool objRefsOnly = orelsToLoad.Remove(objRel);
if (objRelResult == null)
{
continue;
}
if (orelsToLoad.Get(objRel))
{
// fetch only the objRefs, not the objects themselves
continue;
}
IObjRef[] relations = objRelResult.Relations;
if (relations.Length == 0 || objRefsOnly)
{
// fetch only the objRefs, not the objects themselves
continue;
}
if (orisToLoad == null)
{
orisToLoad = cacheToOrisToLoad.Get(cache);
if (orisToLoad == null)
{
orisToLoad = new CHashSet <IObjRef>();
cacheToOrisToLoad.Put(cache, orisToLoad);
}
}
orisToLoad.AddAll(relations);
}
IISet <IObjRelation> orelsLoadedHistory = cacheToOrelsLoadedHistory.Get(cache);
if (orelsLoadedHistory == null)
{
orelsLoadedHistory = new CHashSet <IObjRelation>();
cacheToOrelsLoadedHistory.Put(cache, orelsLoadedHistory);
}
orelsLoadedHistory.AddAll(objRelList);
}
protected virtual void Merge(Object obj, Object clone, MergeHandle handle)
{
IEntityMetaDataProvider entityMetaDataProvider = this.EntityMetaDataProvider;
IEntityMetaData metaData = ((IEntityMetaDataHolder)obj).Get__EntityMetaData();
bool fieldBasedMergeActive = handle.FieldBasedMergeActive;
bool oneChangeOccured = false;
try
{
RelationMember[] relationMembers = metaData.RelationMembers;
if (relationMembers.Length > 0)
{
IObjRefContainer vhc = (IObjRefContainer)obj;
for (int relationIndex = relationMembers.Length; relationIndex-- > 0;)
{
RelationMember relationMember = relationMembers[relationIndex];
if (!metaData.IsMergeRelevant(relationMember))
{
continue;
}
if (ValueHolderState.INIT != vhc.Get__State(relationIndex))
{
// v2 valueholder is not initialized. so a change is impossible
continue;
}
Object objMember = relationMember.GetValue(obj, false);
Object cloneMember = relationMember.GetValue(clone, false);
if (objMember is IDataObject && !((IDataObject)objMember).HasPendingChanges)
{
IEntityMetaData relationMetaData = entityMetaDataProvider.GetMetaData(relationMember.RealType);
if (EqualsReferenceOrId(objMember, cloneMember, handle, relationMetaData))
{
continue;
}
}
IEntityMetaData childMetaData = entityMetaDataProvider.GetMetaData(relationMember.ElementType);
if (IsMemberModified(objMember, cloneMember, handle, childMetaData))
{
oneChangeOccured = true;
AddOriModification(obj, relationMember.Name, objMember, cloneMember, handle);
}
}
}
if (fieldBasedMergeActive)
{
MergePrimitivesFieldBased(metaData, obj, clone, handle);
return;
}
bool additionalRound;
do
{
additionalRound = !oneChangeOccured;
foreach (PrimitiveMember primitiveMember in metaData.PrimitiveMembers)
{
if (!metaData.IsMergeRelevant(primitiveMember))
{
continue;
}
Object objValue = primitiveMember.GetValue(obj, true);
if (oneChangeOccured)
{
AddModification(obj, primitiveMember.Name, primitiveMember.ElementType, objValue, null, handle);
continue;
}
Object cloneValue = primitiveMember.GetValue(clone, true);
if (!ArePrimitivesEqual(metaData, primitiveMember, objValue, cloneValue, handle))
{
oneChangeOccured = true;
break;
}
}
}while (additionalRound && oneChangeOccured);
}
finally
{
PrimitiveMember versionMember = metaData.VersionMember;
if (oneChangeOccured && versionMember != null)
{
// Check for early optimistic locking (Another, later level is directly on persistence layer)
Object versionToMerge = versionMember.GetValue(obj, true);
Object currentVersion = versionMember.GetValue(clone, true);
int compareResult = ((IComparable)versionToMerge).CompareTo(currentVersion);
if (ExactVersionForOptimisticLockingRequired ? compareResult != 0 : compareResult < 0)
{
throw new OptimisticLockException(currentVersion, versionToMerge, obj);
}
}
}
}
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;
}
}
internal ProxyEntityMetaDataProvider(IEntityMetaDataProvider provider)
{
this.Provider = provider;
}
