C# LockMode.LessThan方法代码示例

		/// <summary> 
		/// Construct a locking strategy based on SQL UPDATE statements.
		/// </summary>
		/// <param name="lockable">The metadata for the entity to be locked. </param>
		/// <param name="lockMode">Indictates the type of lock to be acquired. </param>
		/// <remarks>
		/// read-locks are not valid for this strategy.
		/// </remarks>
		public UpdateLockingStrategy(ILockable lockable, LockMode lockMode)
		{
			this.lockable = lockable;
			this.lockMode = lockMode;
			if (lockMode.LessThan(LockMode.Upgrade))
			{
				throw new HibernateException("[" + lockMode + "] not valid for update statement");
			}
			if (!lockable.IsVersioned)
			{
				log.Warn("write locks via update not supported for non-versioned entities [" + lockable.EntityName + "]");
				sql = null;
			}
			else
			{
				sql = GenerateLockString();
			}
		}

		/// <summary>
		/// Actually do all the hard work of loading up an object
		/// </summary>
		/// <param name="theClass"></param>
		/// <param name="id"></param>
		/// <param name="optionalObject"></param>
		/// <param name="lockMode"></param>
		/// <param name="checkDeleted"></param>
		/// <returns></returns>
		/// <remarks>
		/// 1. see if it is already loaded
		/// 2. see if it is cached
		/// 3. actually go to the database
		/// </remarks>
		private object DoLoad( System.Type theClass, object id, object optionalObject, LockMode lockMode, bool checkDeleted )
		{
			//DONT need to flush before a load by id, because ids are constant

			if( log.IsDebugEnabled )
			{
				log.Debug( "attempting to resolve " + MessageHelper.InfoString( theClass, id ) );
			}

			IClassPersister persister = GetClassPersister( theClass );
			Key key = new Key( id, persister );

			if( optionalObject != null )
			{
				persister.SetIdentifier( optionalObject, id );
			}

			// LOOK FOR LOADED OBJECT 
			// Look for Status.Loaded object
			object old = GetEntity( key );
			if( old != null )
			{
				//if this object was already loaded
				EntityEntry oldEntry = GetEntry( old );
				Status status = oldEntry.Status;
				if( checkDeleted && ( status == Status.Deleted || status == Status.Gone ) )
				{
					throw new ObjectDeletedException( "The object with that id was deleted", id, theClass );
				}
				UpgradeLock( old, oldEntry, lockMode );
				if( log.IsDebugEnabled )
				{
					log.Debug( "resolved object in session cache " + MessageHelper.InfoString( persister, id ) );
				}
				return old;

			}
			else
			{
				// check to see if we know already that it does not exist:
				if( nonExists.Contains( key ) )
				{
					log.Debug( "entity does not exist" );
					return null;
				}

				// LOOK IN CACHE
				CacheEntry entry = persister.HasCache && lockMode.LessThan( LockMode.Read ) ?
					( CacheEntry ) persister.Cache.Get( id, Timestamp ) :
					null;

				if( entry != null )
				{
					return AssembleCacheEntry( entry, id, persister, optionalObject );
				}
				else
				{
					//GO TO DATABASE
					if( log.IsDebugEnabled )
					{
						log.Debug( "object not resolved in any cache " + MessageHelper.InfoString( persister, id ) );
					}
					object result = persister.Load( id, optionalObject, lockMode, this );
					if( result == null )
					{
						// remember it doesn't exist, in case of next time
						AddNonExist( key );
					}
					return result;
				}
			}
		}