public GameList(LoadEvent le) { InitializeComponent(); Program.GamesRepository.GameInstalled += new EventHandler(GamesRepository_GameInstalled); if (le == LoadEvent.InstallGame) Install_Game(); }
public GameList(LoadEvent le) { InitializeComponent(); Program.GamesRepository.GameInstalled += GamesRepositoryGameInstalled; if (le == LoadEvent.InstallGame) InstallGame(); }
private Status _status; // status of plug-in, does allow to load or not; #endregion Fields #region Constructors public Plugin() { _name = ""; _filePath = ""; _status = PluginForm.Status.Disable; _loadEvent = LoadEvent.onClick; }
/// <summary> /// Attempts to locate the entity in the session-level cache. /// </summary> /// <param name="event">The load event </param> /// <param name="keyToLoad">The EntityKey representing the entity to be loaded. </param> /// <param name="options">The load options. </param> /// <returns> The entity from the session-level cache, or null. </returns> /// <remarks> /// If allowed to return nulls, then if the entity happens to be found in /// the session cache, we check the entity type for proper handling /// of entity hierarchies. /// If checkDeleted was set to true, then if the entity is found in the /// session-level cache, it's current status within the session cache /// is checked to see if it has previously been scheduled for deletion. /// </remarks> protected virtual object LoadFromSessionCache(LoadEvent @event, EntityKey keyToLoad, LoadType options) { ISessionImplementor session = @event.Session; object old = session.GetEntityUsingInterceptor(keyToLoad); if (old != null) { // this object was already loaded EntityEntry oldEntry = session.PersistenceContext.GetEntry(old); if (options.IsCheckDeleted) { Status status = oldEntry.Status; if (status == Status.Deleted || status == Status.Gone) { return RemovedEntityMarker; } } if (options.IsAllowNulls) { IEntityPersister persister = GetEntityPersister(@event.Session.Factory, @event.EntityClassName); if (!persister.IsInstance(old, @event.Session.EntityMode)) { return InconsistentRTNClassMarker; } } UpgradeLock(old, oldEntry, @event.LockMode, session); } return old; }
/// <summary> /// Coordinates the efforts to load a given entity. First, an attempt is /// made to load the entity from the session-level cache. If not found there, /// an attempt is made to locate it in second-level cache. Lastly, an /// attempt is made to load it directly from the datasource. /// </summary> /// <param name="event">The load event </param> /// <param name="persister">The persister for the entity being requested for load </param> /// <param name="keyToLoad">The EntityKey representing the entity to be loaded. </param> /// <param name="options">The load options. </param> /// <returns> The loaded entity, or null. </returns> protected virtual object DoLoad(LoadEvent @event, IEntityPersister persister, EntityKey keyToLoad, LoadType options) { if (log.IsDebugEnabled) { log.Debug("attempting to resolve: " + MessageHelper.InfoString(persister, @event.EntityId, @event.Session.Factory)); } object entity = LoadFromSessionCache(@event, keyToLoad, options); if (entity == RemovedEntityMarker) { log.Debug("load request found matching entity in context, but it is scheduled for removal; returning null"); return null; } if (entity == InconsistentRTNClassMarker) { log.Debug("load request found matching entity in context, but the matched entity was of an inconsistent return type; returning null"); return null; } if (entity != null) { if (log.IsDebugEnabled) { log.Debug("resolved object in session cache: " + MessageHelper.InfoString(persister, @event.EntityId, @event.Session.Factory)); } return entity; } entity = LoadFromSecondLevelCache(@event, persister, options); if (entity != null) { if (log.IsDebugEnabled) { log.Debug("resolved object in second-level cache: " + MessageHelper.InfoString(persister, @event.EntityId, @event.Session.Factory)); } return entity; } if (log.IsDebugEnabled) { log.Debug("object not resolved in any cache: " + MessageHelper.InfoString(persister, @event.EntityId, @event.Session.Factory)); } return LoadFromDatasource(@event, persister, keyToLoad, options); }
/// <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 = new CacheKey(@event.EntityId, persister.IdentifierType, persister.RootEntityName, source.EntityMode, source.Factory); 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; }
/// <summary> /// Given that there is a pre-existing proxy. /// Initialize it if necessary; narrow if necessary. /// </summary> private object ReturnNarrowedProxy(LoadEvent @event, IEntityPersister persister, EntityKey keyToLoad, LoadType options, IPersistenceContext persistenceContext, object proxy) { log.Debug("entity proxy found in session cache"); var castedProxy = (INHibernateProxy) proxy; ILazyInitializer li = castedProxy.HibernateLazyInitializer; if (li.Unwrap) { return li.GetImplementation(); } object impl = null; if (!options.IsAllowProxyCreation) { impl = Load(@event, persister, keyToLoad, options); // NH Different behavior : NH-1252 if (impl == null && !options.IsAllowNulls) { @event.Session.Factory.EntityNotFoundDelegate.HandleEntityNotFound(persister.EntityName, keyToLoad.Identifier); } } if (impl == null && !options.IsAllowProxyCreation && options.ExactPersister) { // NH Different behavior : NH-1252 return null; } return persistenceContext.NarrowProxy(castedProxy, persister, keyToLoad, impl); }
private object AssembleCacheEntry(CacheEntry entry, object id, IEntityPersister persister, LoadEvent @event) { object optionalObject = @event.InstanceToLoad; IEventSource session = @event.Session; ISessionFactoryImplementor factory = session.Factory; if (log.IsDebugEnabled) { log.Debug("assembling entity from second-level cache: " + MessageHelper.InfoString(persister, id, factory)); } IEntityPersister subclassPersister = factory.GetEntityPersister(entry.Subclass); object result = optionalObject ?? session.Instantiate(subclassPersister, id); // make it circular-reference safe TwoPhaseLoad.AddUninitializedCachedEntity(new EntityKey(id, subclassPersister, session.EntityMode), result, subclassPersister, LockMode.None, entry.AreLazyPropertiesUnfetched, entry.Version, session); IType[] types = subclassPersister.PropertyTypes; object[] values = entry.Assemble(result, id, subclassPersister, session.Interceptor, session); // intializes result by side-effect TypeFactory.DeepCopy(values, types, subclassPersister.PropertyUpdateability, values, session); object version = Versioning.GetVersion(values, subclassPersister); if (log.IsDebugEnabled) { log.Debug("Cached Version: " + version); } IPersistenceContext persistenceContext = session.PersistenceContext; persistenceContext.AddEntry(result, Status.Loaded, values, null, id, version, LockMode.None, true, subclassPersister, false, entry.AreLazyPropertiesUnfetched); subclassPersister.AfterInitialize(result, entry.AreLazyPropertiesUnfetched, session); persistenceContext.InitializeNonLazyCollections(); // upgrade the lock if necessary: //lock(result, lockMode); //PostLoad is needed for EJB3 //TODO: reuse the PostLoadEvent... PostLoadEvent postLoadEvent = new PostLoadEvent(session); postLoadEvent.Entity = result; postLoadEvent.Id = id; postLoadEvent.Persister = persister; IPostLoadEventListener[] listeners = session.Listeners.PostLoadEventListeners; for (int i = 0; i < listeners.Length; i++) { listeners[i].OnPostLoad(postLoadEvent); } return(result); }
private async Task <object> AssembleCacheEntryAsync(CacheEntry entry, object id, IEntityPersister persister, LoadEvent @event, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); object optionalObject = @event.InstanceToLoad; IEventSource session = @event.Session; ISessionFactoryImplementor factory = session.Factory; if (log.IsDebugEnabled()) { log.Debug("assembling entity from second-level cache: {0}", MessageHelper.InfoString(persister, id, factory)); } IEntityPersister subclassPersister = factory.GetEntityPersister(entry.Subclass); object result = optionalObject ?? session.Instantiate(subclassPersister, id); // make it circular-reference safe EntityKey entityKey = session.GenerateEntityKey(id, subclassPersister); TwoPhaseLoad.AddUninitializedCachedEntity(entityKey, result, subclassPersister, LockMode.None, entry.AreLazyPropertiesUnfetched, entry.Version, session); IType[] types = subclassPersister.PropertyTypes; object[] values = await(entry.AssembleAsync(result, id, subclassPersister, session.Interceptor, session, cancellationToken)).ConfigureAwait(false); // intializes result by side-effect TypeHelper.DeepCopy(values, types, subclassPersister.PropertyUpdateability, values, session); object version = Versioning.GetVersion(values, subclassPersister); if (log.IsDebugEnabled()) { log.Debug("Cached Version: {0}", version); } IPersistenceContext persistenceContext = session.PersistenceContext; bool isReadOnly = session.DefaultReadOnly; if (persister.IsMutable) { object proxy = persistenceContext.GetProxy(entityKey); if (proxy != null) { // this is already a proxy for this impl // only set the status to read-only if the proxy is read-only isReadOnly = ((INHibernateProxy)proxy).HibernateLazyInitializer.ReadOnly; } } else { isReadOnly = true; } persistenceContext.AddEntry( result, isReadOnly ? Status.ReadOnly : Status.Loaded, values, null, id, version, LockMode.None, true, subclassPersister, false, entry.AreLazyPropertiesUnfetched); subclassPersister.AfterInitialize(result, entry.AreLazyPropertiesUnfetched, session); await(persistenceContext.InitializeNonLazyCollectionsAsync(cancellationToken)).ConfigureAwait(false); // upgrade the lock if necessary: //lock(result, lockMode); //PostLoad is needed for EJB3 //TODO: reuse the PostLoadEvent... PostLoadEvent postLoadEvent = new PostLoadEvent(session); postLoadEvent.Entity = result; postLoadEvent.Id = id; postLoadEvent.Persister = persister; IPostLoadEventListener[] listeners = session.Listeners.PostLoadEventListeners; for (int i = 0; i < listeners.Length; i++) { listeners[i].OnPostLoad(postLoadEvent); } return(result); }
public void ReverseLoad(LoadEvent loadEvent) { }
public void HandleLoad(LoadEvent loadEvent) { }
private void ProcessLoadEvent(LoadEvent loadEvent) { //Turn Room On/Off based on event }
protected override object DoLoad(LoadEvent @event, IEntityPersister persister, EntityKey keyToLoad, LoadType options) { return(base.DoLoad(@event, persister, keyToLoad, options)); }
/// <summary> /// The handler that creates a new loaded view /// </summary> /// <param name="message">Not used</param> public void Handle(LoadEvent message) { ActivateItem(new LoadViewModel(_events)); }
private object AssembleCacheEntry(CacheEntry entry, object id, IEntityPersister persister, LoadEvent @event) { object optionalObject = @event.InstanceToLoad; IEventSource session = @event.Session; ISessionFactoryImplementor factory = session.Factory; if (log.IsDebugEnabled) { log.Debug("assembling entity from second-level cache: " + MessageHelper.InfoString(persister, id, factory)); } IEntityPersister subclassPersister = factory.GetEntityPersister(entry.Subclass); object result = optionalObject ?? session.Instantiate(subclassPersister, id); // make it circular-reference safe EntityKey entityKey = new EntityKey(id, subclassPersister, session.EntityMode); TwoPhaseLoad.AddUninitializedCachedEntity(entityKey, result, subclassPersister, LockMode.None, entry.AreLazyPropertiesUnfetched, entry.Version, session); IType[] types = subclassPersister.PropertyTypes; object[] values = entry.Assemble(result, id, subclassPersister, session.Interceptor, session); // intializes result by side-effect TypeHelper.DeepCopy(values, types, subclassPersister.PropertyUpdateability, values, session); object version = Versioning.GetVersion(values, subclassPersister); if (log.IsDebugEnabled) { log.Debug("Cached Version: " + version); } IPersistenceContext persistenceContext = session.PersistenceContext; bool isReadOnly = session.DefaultReadOnly; if (persister.IsMutable) { object proxy = persistenceContext.GetProxy(entityKey); if (proxy != null) { // this is already a proxy for this impl // only set the status to read-only if the proxy is read-only isReadOnly = ((INHibernateProxy)proxy).HibernateLazyInitializer.ReadOnly; } } else isReadOnly = true; persistenceContext.AddEntry( result, isReadOnly ? Status.ReadOnly : Status.Loaded, values, null, id, version, LockMode.None, true, subclassPersister, false, entry.AreLazyPropertiesUnfetched); subclassPersister.AfterInitialize(result, entry.AreLazyPropertiesUnfetched, session); persistenceContext.InitializeNonLazyCollections(); // upgrade the lock if necessary: //lock(result, lockMode); //PostLoad is needed for EJB3 //TODO: reuse the PostLoadEvent... PostLoadEvent postLoadEvent = new PostLoadEvent(session); postLoadEvent.Entity = result; postLoadEvent.Id = id; postLoadEvent.Persister = persister; IPostLoadEventListener[] listeners = session.Listeners.PostLoadEventListeners; for (int i = 0; i < listeners.Length; i++) { listeners[i].OnPostLoad(postLoadEvent); } return result; }
public void OnLoad(LoadEvent @event, LoadType loadType) { log.Debug("OnLoad :" + @event); }
protected virtual void OnLoadEvent(LoadEventArgs e) { LoadEvent?.Invoke(this, e); }
public virtual void OnLoad(LoadEvent @event, LoadType loadType) { ISessionImplementor source = @event.Session; IEntityPersister persister; if (@event.InstanceToLoad != null) { persister = source.GetEntityPersister(null, @event.InstanceToLoad); //the load() which takes an entity does not pass an entityName @event.EntityClassName = @event.InstanceToLoad.GetType().FullName; } else { persister = source.Factory.GetEntityPersister(@event.EntityClassName); } if (persister == null) { throw new HibernateException("Unable to locate persister: " + @event.EntityClassName); } if (persister.IdentifierType.IsComponentType) { // skip this check for composite-ids relating to dom4j entity-mode; // alternatively, we could add a check to make sure the incoming id value is // an instance of Element... } else { System.Type idClass = persister.IdentifierType.ReturnedClass; if (idClass != null && !idClass.IsInstanceOfType(@event.EntityId)) { throw new TypeMismatchException("Provided id of the wrong type. Expected: " + idClass + ", got " + @event.EntityId.GetType()); } } EntityKey keyToLoad = new EntityKey(@event.EntityId, persister, source.EntityMode); try { if (loadType.IsNakedEntityReturned) { //do not return a proxy! //(this option indicates we are initializing a proxy) @event.Result = Load(@event, persister, keyToLoad, loadType); } else { //return a proxy if appropriate if (@event.LockMode == LockMode.None) { @event.Result = ProxyOrLoad(@event, persister, keyToLoad, loadType); } else { @event.Result = LockAndLoad(@event, persister, keyToLoad, loadType, source); } } } catch (HibernateException e) { log.Info("Error performing load command", e); throw; } }
/// <summary> /// Do not call this constructor. Use SxLib.InitializeWinForms instead. /// </summary> /// <param name="_Current"></param> /// <param name="_SynapseDir"></param> protected internal SxLibWinForms(Form _Current, string _SynapseDir) : base(_SynapseDir) { Current = _Current; LoadEventInternal += delegate(SynLoadEvents LEvent, object Param) { Current.Invoke(new Action(() => { LoadEvent?.Invoke(LEvent, Param); })); }; AttachEventInternal += delegate(SynAttachEvents AEvent, object Param) { Current.Invoke(new Action(() => { AttachEvent?.Invoke(AEvent, Param); })); }; HubEventInternal += delegate(List <SynHubEntry> Entries) { Current.Invoke(new Action(() => { ScriptHubEvent?.Invoke(Entries); })); }; }
/// <summary> /// Performs the process of loading an entity from the configured underlying datasource. /// </summary> /// <param name="event">The load event </param> /// <param name="persister">The persister for the entity being requested for load </param> /// <param name="keyToLoad">The EntityKey representing the entity to be loaded. </param> /// <param name="options">The load options. </param> /// <returns> The object loaded from the datasource, or null if not found. </returns> protected virtual object LoadFromDatasource(LoadEvent @event, IEntityPersister persister, EntityKey keyToLoad, LoadType options) { ISessionImplementor source = @event.Session; object entity = persister.Load(@event.EntityId, @event.InstanceToLoad, @event.LockMode, source); if (@event.IsAssociationFetch && source.Factory.Statistics.IsStatisticsEnabled) { source.Factory.StatisticsImplementor.FetchEntity(@event.EntityClassName); } return entity; }
public void LoadEventOperation() { LoadEvent?.Invoke(this, EventArgs.Empty); }
/// <summary> /// Based on configured options, will either return a pre-existing proxy, /// generate a new proxy, or perform an actual load. /// </summary> /// <returns> The result of the proxy/load operation.</returns> protected virtual object ProxyOrLoad(LoadEvent @event, IEntityPersister persister, EntityKey keyToLoad, LoadType options) { if (log.IsDebugEnabled) { log.Debug("loading entity: " + MessageHelper.InfoString(persister, @event.EntityId, @event.Session.Factory)); } if (!persister.HasProxy) { // this class has no proxies (so do a shortcut) return Load(@event, persister, keyToLoad, options); } else { IPersistenceContext persistenceContext = @event.Session.PersistenceContext; // look for a proxy object proxy = persistenceContext.GetProxy(keyToLoad); if (proxy != null) { return ReturnNarrowedProxy(@event, persister, keyToLoad, options, persistenceContext, proxy); } else { if (options.IsAllowProxyCreation) { return CreateProxyIfNecessary(@event, persister, keyToLoad, options, persistenceContext); } else { // return a newly loaded object return Load(@event, persister, keyToLoad, options); } } } }
public virtual void Refresh() { LoadEvent.Invoke(); }
/// <summary> /// Given that there is no pre-existing proxy. /// Check if the entity is already loaded. If it is, return the entity, /// otherwise create and return a proxy. /// </summary> private object CreateProxyIfNecessary(LoadEvent @event, IEntityPersister persister, EntityKey keyToLoad, LoadType options, IPersistenceContext persistenceContext) { object existing = persistenceContext.GetEntity(keyToLoad); if (existing != null) { // return existing object or initialized proxy (unless deleted) log.Debug("entity found in session cache"); if (options.IsCheckDeleted) { EntityEntry entry = persistenceContext.GetEntry(existing); Status status = entry.Status; if (status == Status.Deleted || status == Status.Gone) { return null; } } return existing; } else { log.Debug("creating new proxy for entity"); // return new uninitialized proxy object proxy = persister.CreateProxy(@event.EntityId, @event.Session); persistenceContext.BatchFetchQueue.AddBatchLoadableEntityKey(keyToLoad); persistenceContext.AddProxy(keyToLoad, (INHibernateProxy)proxy); ((INHibernateProxy)proxy) .HibernateLazyInitializer .ReadOnly = @event.Session.DefaultReadOnly || !persister.IsMutable; return proxy; } }
internal void InitScript(UUIView _script) { Script = _script; LoadEvent?.Invoke(Script); LoadEvent = null; }
public virtual void OnLoad(LoadEvent @event, LoadType loadType) { ISessionImplementor source = @event.Session; IEntityPersister persister; if (@event.InstanceToLoad != null) { persister = source.GetEntityPersister(null, @event.InstanceToLoad); //the load() which takes an entity does not pass an entityName @event.EntityClassName = @event.InstanceToLoad.GetType().FullName; } else { persister = GetEntityPersister(source.Factory, @event.EntityClassName); } if (persister == null) { throw new HibernateException("Unable to locate persister: " + @event.EntityClassName); } if (persister.IdentifierType.IsComponentType) { // skip this check for composite-ids relating to dom4j entity-mode; // alternatively, we could add a check to make sure the incoming id value is // an instance of Element... } else { System.Type idClass = persister.IdentifierType.ReturnedClass; if (idClass != null && !idClass.IsInstanceOfType(@event.EntityId)) { throw new TypeMismatchException("Provided id of the wrong type. Expected: " + idClass + ", got " + @event.EntityId.GetType()); } } EntityKey keyToLoad = new EntityKey(@event.EntityId, persister, source.EntityMode); try { if (loadType.IsNakedEntityReturned) { //do not return a proxy! //(this option indicates we are initializing a proxy) @event.Result = Load(@event, persister, keyToLoad, loadType); } else { //return a proxy if appropriate if (@event.LockMode == LockMode.None) { @event.Result = ProxyOrLoad(@event, persister, keyToLoad, loadType); } else { @event.Result = LockAndLoad(@event, persister, keyToLoad, loadType, source); } } } catch (HibernateException e) { log.Info("Error performing load command", e); throw; } }
/// <summary> Attempts to load the entity from the second-level cache. </summary> /// <param name="event">The load event </param> /// <param name="persister">The persister for the entity being requested for load </param> /// <param name="options">The load options. </param> /// <param name="cancellationToken">A cancellation token that can be used to cancel the work</param> /// <returns> The entity from the second-level cache, or null. </returns> protected virtual async Task <object> LoadFromSecondLevelCacheAsync(LoadEvent @event, IEntityPersister persister, LoadType options, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); ISessionImplementor source = @event.Session; bool useCache = persister.HasCache && source.CacheMode.HasFlag(CacheMode.Get) && @event.LockMode.LessThan(LockMode.Read); if (!useCache) { return(null); } ISessionFactoryImplementor factory = source.Factory; var batchSize = persister.GetBatchSize(); if (batchSize > 1 && persister.Cache.PreferMultipleGet()) { // The first item in the array is the item that we want to load var entityBatch = await(source.PersistenceContext.BatchFetchQueue.GetEntityBatchAsync(persister, @event.EntityId, batchSize, false, cancellationToken)).ConfigureAwait(false); // Ignore null values as the retrieved batch may contains them when there are not enough // uninitialized entities in the queue var keys = new List <CacheKey>(batchSize); for (var i = 0; i < entityBatch.Length; i++) { var key = entityBatch[i]; if (key == null) { break; } keys.Add(source.GenerateCacheKey(key, persister.IdentifierType, persister.RootEntityName)); } var cachedObjects = await(persister.Cache.GetManyAsync(keys.ToArray(), source.Timestamp, cancellationToken)).ConfigureAwait(false); for (var i = 1; i < cachedObjects.Length; i++) { cancellationToken.ThrowIfCancellationRequested(); await(AssembleAsync( keys[i], cachedObjects[i], new LoadEvent(entityBatch[i], @event.EntityClassName, @event.LockMode, @event.Session), false)).ConfigureAwait(false); } cancellationToken.ThrowIfCancellationRequested(); return(await(AssembleAsync(keys[0], cachedObjects[0], @event, true)).ConfigureAwait(false)); } var cacheKey = source.GenerateCacheKey(@event.EntityId, persister.IdentifierType, persister.RootEntityName); var cachedObject = await(persister.Cache.GetAsync(cacheKey, source.Timestamp, cancellationToken)).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); return(await(AssembleAsync(cacheKey, cachedObject, @event, true)).ConfigureAwait(false)); Task <object> AssembleAsync(CacheKey ck, object ce, LoadEvent evt, bool alterStatistics) { if (factory.Statistics.IsStatisticsEnabled && alterStatistics) { if (ce == null) { factory.StatisticsImplementor.SecondLevelCacheMiss(persister.Cache.RegionName); log.Debug("Entity cache miss: {0}", ck); } else { factory.StatisticsImplementor.SecondLevelCacheHit(persister.Cache.RegionName); log.Debug("Entity cache hit: {0}", ck); } } if (ce != null) { CacheEntry entry = (CacheEntry)persister.CacheEntryStructure.Destructure(ce, factory); // Entity was found in second-level cache... // NH: Different behavior (take a look to options.ExactPersister (NH-295)) if (!options.ExactPersister || persister.EntityMetamodel.SubclassEntityNames.Contains(entry.Subclass)) { return(AssembleCacheEntryAsync(entry, evt.EntityId, persister, evt, cancellationToken)); } } return(Task.FromResult <object>(null)); } }
/// <summary> /// Performs the process of loading an entity from the configured underlying datasource. /// </summary> /// <param name="event">The load event </param> /// <param name="persister">The persister for the entity being requested for load </param> /// <param name="keyToLoad">The EntityKey representing the entity to be loaded. </param> /// <param name="options">The load options. </param> /// <returns> The object loaded from the datasource, or null if not found. </returns> protected virtual object LoadFromDatasource(LoadEvent @event, IEntityPersister persister, EntityKey keyToLoad, LoadType options) { ISessionImplementor source = @event.Session; bool statsEnabled = source.Factory.Statistics.IsStatisticsEnabled; var stopWath = new Stopwatch(); if (statsEnabled) { stopWath.Start(); } object entity = persister.Load(@event.EntityId, @event.InstanceToLoad, @event.LockMode, source); if (@event.IsAssociationFetch && statsEnabled) { stopWath.Stop(); source.Factory.StatisticsImplementor.FetchEntity(@event.EntityClassName, stopWath.Elapsed); } return entity; }
public void OnLoad(LoadEvent @event, LoadType loadType) { }
/// <summary> Attempts to load the entity from the second-level cache. </summary> /// <param name="event">The load event </param> /// <param name="persister">The persister for the entity being requested for load </param> /// <param name="options">The load options. </param> /// <returns> The entity from the second-level cache, or null. </returns> protected virtual object LoadFromSecondLevelCache(LoadEvent @event, IEntityPersister persister, LoadType options) { ISessionImplementor source = @event.Session; bool useCache = persister.HasCache && ((source.CacheMode & CacheMode.Get) == CacheMode.Get) && @event.LockMode.LessThan(LockMode.Read); if (useCache) { ISessionFactoryImplementor factory = source.Factory; CacheKey ck = new CacheKey(@event.EntityId, persister.IdentifierType, persister.RootEntityName, source.EntityMode, factory); object ce = persister.Cache.Get(ck, source.Timestamp); if (factory.Statistics.IsStatisticsEnabled) { if (ce == null) { factory.StatisticsImplementor.SecondLevelCacheMiss(persister.Cache.RegionName); log.DebugFormat("Entity cache miss: {0}", ck); } else { factory.StatisticsImplementor.SecondLevelCacheHit(persister.Cache.RegionName); log.DebugFormat("Entity cache hit: {0}", ck); } } if (ce != null) { CacheEntry entry = (CacheEntry) persister.CacheEntryStructure.Destructure(ce, factory); // Entity was found in second-level cache... // NH: Different behavior (take a look to options.ExactPersister (NH-295)) if (!options.ExactPersister || persister.EntityMetamodel.SubclassEntityNames.Contains(entry.Subclass)) { return AssembleCacheEntry(entry, @event.EntityId, persister, @event); } } } return null; }
public virtual async Task OnLoadAsync(LoadEvent @event, LoadType loadType, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); ISessionImplementor source = @event.Session; IEntityPersister persister; if (@event.InstanceToLoad != null) { persister = source.GetEntityPersister(null, @event.InstanceToLoad); //the load() which takes an entity does not pass an entityName @event.EntityClassName = @event.InstanceToLoad.GetType().FullName; } else { persister = GetEntityPersister(source.Factory, @event.EntityClassName); } if (persister == null) { var message = new StringBuilder(512); message.AppendLine(string.Format("Unable to locate persister for the entity named '{0}'.", @event.EntityClassName)); message.AppendLine("The persister define the persistence strategy for an entity."); message.AppendLine("Possible causes:"); message.AppendLine(string.Format(" - The mapping for '{0}' was not added to the NHibernate configuration.", @event.EntityClassName)); throw new HibernateException(message.ToString()); } if (persister.IdentifierType.IsComponentType) { // skip this check for composite-ids relating to dom4j entity-mode; // alternatively, we could add a check to make sure the incoming id value is // an instance of Element... } else { System.Type idClass = persister.IdentifierType.ReturnedClass; if (idClass != null && !idClass.IsInstanceOfType(@event.EntityId)) { throw new TypeMismatchException("Provided id of the wrong type. Expected: " + idClass + ", got " + @event.EntityId.GetType()); } } EntityKey keyToLoad = source.GenerateEntityKey(@event.EntityId, persister); try { if (loadType.IsNakedEntityReturned) { //do not return a proxy! //(this option indicates we are initializing a proxy) @event.Result = await(LoadAsync(@event, persister, keyToLoad, loadType, cancellationToken)).ConfigureAwait(false); } else { //return a proxy if appropriate if (@event.LockMode == LockMode.None) { @event.Result = await(ProxyOrLoadAsync(@event, persister, keyToLoad, loadType, cancellationToken)).ConfigureAwait(false); } else { @event.Result = await(LockAndLoadAsync(@event, persister, keyToLoad, loadType, source, cancellationToken)).ConfigureAwait(false); } } } catch (HibernateException e) { log.Info(e, "Error performing load command"); throw; } }
/// <summary> Perfoms the load of an entity. </summary> /// <returns> The loaded entity. </returns> protected virtual object Load(LoadEvent @event, IEntityPersister persister, EntityKey keyToLoad, LoadType options) { if (@event.InstanceToLoad != null) { if (@event.Session.PersistenceContext.GetEntry(@event.InstanceToLoad) != null) { throw new PersistentObjectException("attempted to load into an instance that was already associated with the session: " + MessageHelper.InfoString(persister, @event.EntityId, @event.Session.Factory)); } persister.SetIdentifier(@event.InstanceToLoad, @event.EntityId, @event.Session.EntityMode); } object entity = DoLoad(@event, persister, keyToLoad, options); bool isOptionalInstance = @event.InstanceToLoad != null; if (!options.IsAllowNulls || isOptionalInstance) { if (entity == null) { @event.Session.Factory.EntityNotFoundDelegate.HandleEntityNotFound(@event.EntityClassName, @event.EntityId); } } if (isOptionalInstance && entity != @event.InstanceToLoad) { throw new NonUniqueObjectException(@event.EntityId, @event.EntityClassName); } return entity; }
/// <summary> /// Do not call this constructor. Use SxLib.InitializeWPF instead. /// </summary> /// <param name="_Current"></param> /// <param name="_SynapseDir"></param> protected internal SxLibWPF(Window _Current, string _SynapseDir) : base(_SynapseDir) { Current = _Current; LoadEventInternal += delegate(SynLoadEvents LEvent, object Param) { Current.Dispatcher.Invoke(() => { LoadEvent?.Invoke(LEvent, Param); }); }; AttachEventInternal += delegate(SynAttachEvents AEvent, object Param) { Current.Dispatcher.Invoke(() => { AttachEvent?.Invoke(AEvent, Param); }); }; HubEventInternal += delegate(List <SynHubEntry> Entries) { Current.Dispatcher.Invoke(() => { ScriptHubEvent?.Invoke(Entries); }); }; }