本文整理汇总了C#中ISessionImplementor.GenerateCacheKey方法的典型用法代码示例。如果您正苦于以下问题:C# ISessionImplementor.GenerateCacheKey方法的具体用法?C# ISessionImplementor.GenerateCacheKey怎么用?C# ISessionImplementor.GenerateCacheKey使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类ISessionImplementor
的用法示例。
在下文中一共展示了ISessionImplementor.GenerateCacheKey方法的6个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: InitializeCollectionFromCache
/// <summary> Try to initialize a collection from the cache</summary>
private bool InitializeCollectionFromCache(object id, ICollectionPersister persister, IPersistentCollection collection, ISessionImplementor source)
{
if (!(source.EnabledFilters.Count == 0) && persister.IsAffectedByEnabledFilters(source))
{
log.Debug("disregarding cached version (if any) of collection due to enabled filters ");
return false;
}
bool useCache = persister.HasCache && ((source.CacheMode & CacheMode.Get) == CacheMode.Get);
if (!useCache)
{
return false;
}
else
{
ISessionFactoryImplementor factory = source.Factory;
CacheKey ck = source.GenerateCacheKey(id, persister.KeyType, persister.Role);
object ce = persister.Cache.Get(ck, source.Timestamp);
if (factory.Statistics.IsStatisticsEnabled)
{
if (ce == null)
{
factory.StatisticsImplementor.SecondLevelCacheMiss(persister.Cache.RegionName);
}
else
{
factory.StatisticsImplementor.SecondLevelCacheHit(persister.Cache.RegionName);
}
}
if (ce == null)
{
log.DebugFormat("Collection cache miss: {0}", ck);
}
else
{
log.DebugFormat("Collection cache hit: {0}", ck);
}
if (ce == null)
{
return false;
}
else
{
IPersistenceContext persistenceContext = source.PersistenceContext;
CollectionCacheEntry cacheEntry = (CollectionCacheEntry)persister.CacheEntryStructure.Destructure(ce, factory);
cacheEntry.Assemble(collection, persister, persistenceContext.GetCollectionOwner(id, persister));
persistenceContext.GetCollectionEntry(collection).PostInitialize(collection);
return true;
}
}
}
示例2: UpgradeLock
/// <summary>
/// Performs a pessimistic lock upgrade on a given entity, if needed.
/// </summary>
/// <param name="entity">The entity for which to upgrade the lock.</param>
/// <param name="entry">The entity's EntityEntry instance.</param>
/// <param name="requestedLockMode">The lock mode being requested for locking. </param>
/// <param name="source">The session which is the source of the event being processed.</param>
protected virtual void UpgradeLock(object entity, EntityEntry entry, LockMode requestedLockMode, ISessionImplementor source)
{
if (requestedLockMode.GreaterThan(entry.LockMode))
{
// The user requested a "greater" (i.e. more restrictive) form of
// pessimistic lock
if (entry.Status != Status.Loaded)
{
throw new ObjectDeletedException("attempted to lock a deleted instance", entry.Id, entry.EntityName);
}
IEntityPersister persister = entry.Persister;
if (log.IsDebugEnabled)
{
log.Debug(string.Format("locking {0} in mode: {1}", MessageHelper.InfoString(persister, entry.Id, source.Factory), requestedLockMode));
}
ISoftLock slock;
CacheKey ck;
if (persister.HasCache)
{
ck = source.GenerateCacheKey(entry.Id, persister.IdentifierType, persister.RootEntityName);
slock = persister.Cache.Lock(ck, entry.Version);
}
else
{
ck = null;
slock = null;
}
try
{
if (persister.IsVersioned && requestedLockMode == LockMode.Force)
{
// todo : should we check the current isolation mode explicitly?
object nextVersion = persister.ForceVersionIncrement(entry.Id, entry.Version, source);
entry.ForceLocked(entity, nextVersion);
}
else
{
persister.Lock(entry.Id, entry.Version, entity, requestedLockMode, source);
}
entry.LockMode = requestedLockMode;
}
finally
{
// the database now holds a lock + the object is flushed from the cache,
// so release the soft lock
if (persister.HasCache)
{
persister.Cache.Release(ck, slock);
}
}
}
}
示例3: IsTransient
public virtual bool? IsTransient(object entity, ISessionImplementor session)
{
object id;
if (CanExtractIdOutOfEntity)
{
id = GetIdentifier(entity, session.EntityMode);
}
else
{
id = null;
}
// we *always* assume an instance with a null
// identifier or no identifier property is unsaved!
if (id == null)
{
return true;
}
// check the version unsaved-value, if appropriate
if (IsVersioned)
{
object version = GetVersion(entity, session.EntityMode);
// let this take precedence if defined, since it works for
// assigned identifiers
bool? result = entityMetamodel.VersionProperty.UnsavedValue.IsUnsaved(version);
if (result.HasValue)
{
return result;
}
}
// check the id unsaved-value
bool? result2 = entityMetamodel.IdentifierProperty.UnsavedValue.IsUnsaved(id);
if (result2.HasValue)
{
if (IdentifierGenerator is Assigned)
{
// if using assigned identifier, we can only make assumptions
// if the value is a known unsaved-value
if (result2.Value)
return true;
}
else
{
return result2;
}
}
// check to see if it is in the second-level cache
if (HasCache)
{
CacheKey ck = session.GenerateCacheKey(id, IdentifierType, RootEntityName);
if (Cache.Get(ck, session.Timestamp) != null)
return false;
}
return null;
}
示例4: InitializeLazyProperty
public virtual object InitializeLazyProperty(string fieldName, object entity, ISessionImplementor session)
{
object id = session.GetContextEntityIdentifier(entity);
EntityEntry entry = session.PersistenceContext.GetEntry(entity);
if (entry == null)
throw new HibernateException("entity is not associated with the session: " + id);
if (log.IsDebugEnabled)
{
log.Debug(
string.Format("initializing lazy properties of: {0}, field access: {1}",
MessageHelper.InfoString(this, id, Factory), fieldName));
}
if (HasCache)
{
CacheKey cacheKey = session.GenerateCacheKey(id, IdentifierType, EntityName);
object ce = Cache.Get(cacheKey, session.Timestamp);
if (ce != null)
{
CacheEntry cacheEntry = (CacheEntry)CacheEntryStructure.Destructure(ce, factory);
if (!cacheEntry.AreLazyPropertiesUnfetched)
{
//note early exit here:
return InitializeLazyPropertiesFromCache(fieldName, entity, session, entry, cacheEntry);
}
}
}
return InitializeLazyPropertiesFromDatastore(fieldName, entity, session, id, entry);
}
示例5: InitializeEntity
/// <summary>
/// Perform the second step of 2-phase load. Fully initialize the entity instance.
/// After processing a JDBC result set, we "resolve" all the associations
/// between the entities which were instantiated and had their state
/// "hydrated" into an array
/// </summary>
public static void InitializeEntity(object entity, bool readOnly, ISessionImplementor session, PreLoadEvent preLoadEvent, PostLoadEvent postLoadEvent)
{
//TODO: Should this be an InitializeEntityEventListener??? (watch out for performance!)
bool statsEnabled = session.Factory.Statistics.IsStatisticsEnabled;
var stopWath = new Stopwatch();
if (statsEnabled)
{
stopWath.Start();
}
IPersistenceContext persistenceContext = session.PersistenceContext;
EntityEntry entityEntry = persistenceContext.GetEntry(entity);
if (entityEntry == null)
{
throw new AssertionFailure("possible non-threadsafe access to the session");
}
IEntityPersister persister = entityEntry.Persister;
object id = entityEntry.Id;
object[] hydratedState = entityEntry.LoadedState;
if (log.IsDebugEnabled)
log.Debug("resolving associations for " + MessageHelper.InfoString(persister, id, session.Factory));
IType[] types = persister.PropertyTypes;
for (int i = 0; i < hydratedState.Length; i++)
{
object value = hydratedState[i];
if (!Equals(LazyPropertyInitializer.UnfetchedProperty, value) && !(Equals(BackrefPropertyAccessor.Unknown, value)))
{
hydratedState[i] = types[i].ResolveIdentifier(value, session, entity);
}
}
//Must occur after resolving identifiers!
if (session.IsEventSource)
{
preLoadEvent.Entity = entity;
preLoadEvent.State = hydratedState;
preLoadEvent.Id = id;
preLoadEvent.Persister=persister;
IPreLoadEventListener[] listeners = session.Listeners.PreLoadEventListeners;
for (int i = 0; i < listeners.Length; i++)
{
listeners[i].OnPreLoad(preLoadEvent);
}
}
persister.SetPropertyValues(entity, hydratedState, session.EntityMode);
ISessionFactoryImplementor factory = session.Factory;
if (persister.HasCache && ((session.CacheMode & CacheMode.Put) == CacheMode.Put))
{
if (log.IsDebugEnabled)
log.Debug("adding entity to second-level cache: " + MessageHelper.InfoString(persister, id, session.Factory));
object version = Versioning.GetVersion(hydratedState, persister);
CacheEntry entry =
new CacheEntry(hydratedState, persister, entityEntry.LoadedWithLazyPropertiesUnfetched, version, session, entity);
CacheKey cacheKey = session.GenerateCacheKey(id, persister.IdentifierType, persister.RootEntityName);
bool put =
persister.Cache.Put(cacheKey, persister.CacheEntryStructure.Structure(entry), session.Timestamp, version,
persister.IsVersioned ? persister.VersionType.Comparator : null,
UseMinimalPuts(session, entityEntry));
if (put && factory.Statistics.IsStatisticsEnabled)
{
factory.StatisticsImplementor.SecondLevelCachePut(persister.Cache.RegionName);
}
}
bool isReallyReadOnly = readOnly;
if (!persister.IsMutable)
{
isReallyReadOnly = true;
}
else
{
object proxy = persistenceContext.GetProxy(entityEntry.EntityKey);
if (proxy != null)
{
// there is already a proxy for this impl
// only set the status to read-only if the proxy is read-only
isReallyReadOnly = ((INHibernateProxy)proxy).HibernateLazyInitializer.ReadOnly;
}
}
if (isReallyReadOnly)
{
//no need to take a snapshot - this is a
//performance optimization, but not really
//important, except for entities with huge
//.........这里部分代码省略.........
示例6: LockAndLoad
/// <summary>
/// If the class to be loaded has been configured with a cache, then lock
/// given id in that cache and then perform the load.
/// </summary>
/// <returns> The loaded entity </returns>
protected virtual object LockAndLoad(LoadEvent @event, IEntityPersister persister, EntityKey keyToLoad, LoadType options, ISessionImplementor source)
{
ISoftLock sLock = null;
CacheKey ck;
if (persister.HasCache)
{
ck = source.GenerateCacheKey(@event.EntityId, persister.IdentifierType, persister.RootEntityName);
sLock = persister.Cache.Lock(ck, null);
}
else
{
ck = null;
}
object entity;
try
{
entity = Load(@event, persister, keyToLoad, options);
}
finally
{
if (persister.HasCache)
{
persister.Cache.Release(ck, sLock);
}
}
object proxy = @event.Session.PersistenceContext.ProxyFor(persister, keyToLoad, entity);
return proxy;
}