public IList <ILoadContainer> GetEntities(IList <IObjRef> orisToLoad)
{
bool isTransaction = false;
if (TransactionState != null)
{
isTransaction = TransactionState.IsTransactionActive;
}
List <ILoadContainer> result = new List <ILoadContainer>();
if (!isTransaction)
{
// Allow committed root cache only OUT OF transactions to retrieve data by itself
IList <Object> loadContainers = CommittedRootCache.GetObjects(orisToLoad, loadContainerResultCD);
for (int a = loadContainers.Count; a-- > 0;)
{
result.Add((ILoadContainer)loadContainers[a]);
}
InternStrings(result);
return(result);
}
List <IObjRef> orisToLoadWithVersion = new List <IObjRef>();
List <IObjRef> missedOris = new List <IObjRef>();
for (int i = orisToLoad.Count; i-- > 0;)
{
IObjRef ori = orisToLoad[i];
if (ori.Version != null)
{
orisToLoadWithVersion.Add(ori);
}
else
{
missedOris.Add(ori);
}
}
IList <Object> loadContainers2 = CommittedRootCache.GetObjects(orisToLoadWithVersion, committedRootCacheCD);
for (int a = loadContainers2.Count; a-- > 0;)
{
ILoadContainer loadContainer = (ILoadContainer)loadContainers2[a];
if (loadContainer == null)
{
missedOris.Add(orisToLoadWithVersion[a]);
}
else
{
result.Add(loadContainer);
}
}
if (missedOris.Count > 0)
{
IList <ILoadContainer> uncommittedLoadContainer = UncommittedCacheRetriever.GetEntities(missedOris);
result.AddRange(uncommittedLoadContainer);
}
InternStrings(result);
return(result);
}
public IList <IObjRelationResult> GetRelations(IList <IObjRelation> objRelations)
{
IList <IObjRelation> orelToLoadWithVersion = new List <IObjRelation>();
IList <IObjRelation> missedOrels = new List <IObjRelation>();
for (int i = objRelations.Count; i-- > 0;)
{
IObjRelation orel = objRelations[i];
if (orel.Version != null)
{
orelToLoadWithVersion.Add(orel);
}
else
{
missedOrels.Add(orel);
}
}
IList <IObjRelationResult> relationResults = CommittedRootCache.GetObjRelations(orelToLoadWithVersion, committedRootCacheCD);
List <IObjRelationResult> result = new List <IObjRelationResult>();
for (int a = relationResults.Count; a-- > 0;)
{
IObjRelationResult relationResult = relationResults[a];
if (relationResult == null)
{
missedOrels.Add(orelToLoadWithVersion[a]);
}
else
{
result.Add(relationResult);
}
}
if (missedOrels.Count > 0)
{
IList <IObjRelationResult> uncommittedRelationResult = UncommittedCacheRetriever.GetRelations(missedOrels);
result.AddRange(uncommittedRelationResult);
}
return(result);
}
public void DisposeTransactionalRootCache(bool success)
{
transactionalRootCacheActiveTL.Value = false;
DisposeCurrentRootCache(rootCacheTL);
IRootCache rootCache = privilegedRootCacheTL.Value;
if (rootCache == null)
{
DisposeCurrentRootCache(privilegedRootCacheTL);
// This may happen if an exception occurs while committing and therefore calling a rollback
return;
}
try
{
if (success)
{
List <RootCacheValue> content = new List <RootCacheValue>();
// Save information into second level cache for committed data
rootCache.GetContent(delegate(Type entityType, sbyte idIndex, Object id, Object value)
{
content.Add((RootCacheValue)value);
}
);
if (content.Count > 0)
{
rootCache.Clear();
CommittedRootCache.Put(content);
}
}
}
finally
{
DisposeCurrentRootCache(privilegedRootCacheTL);
}
}
