C# ISessionImplementor.AddUninitializedEntity方法代码示例

		/// <summary>
		/// Hydrate the state of an object from the SQL <c>IDataReader</c>, into
		/// an array of "hydrated" values (do not resolve associations yet),
		/// and pass the hydrated state to the session.
		/// </summary>
		/// <param name="rs"></param>
		/// <param name="i"></param>
		/// <param name="obj"></param>
		/// <param name="key"></param>
		/// <param name="suffix"></param>
		/// <param name="lockMode"></param>
		/// <param name="rootPersister"></param>
		/// <param name="session"></param>
		private void LoadFromResultSet( IDataReader rs, int i, object obj, Key key, string suffix, LockMode lockMode, ILoadable rootPersister, ISessionImplementor session )
		{
			if( log.IsDebugEnabled )
			{
				log.Debug( "Initializing object from DataReader: " + key );
			}

			// add temp entry so that the next step is circular-reference
			// safe - only needed because some types don't take proper
			// advantage of two-phase-load (esp. components)
			session.AddUninitializedEntity( key, obj, lockMode );

			// Get the persister for the _subclass_
			ILoadable persister = ( ILoadable ) session.GetPersister( obj );

			// This is not very nice (and quite slow):
			string[ ][ ] cols = persister == rootPersister ?
				suffixedPropertyColumns[ i ] :
				GetSuffixedPropertyAliases( persister, suffix );

			object id = key.Identifier;
			object[ ] values = Hydrate( rs, id, obj, persister, session, cols );
			session.PostHydrate( persister, id, values, obj, lockMode );
		}

		public object Load(object id, object optionalObject, LockMode lockMode, ISessionImplementor session)
		{
			Custom clone = null;
			Custom obj = (Custom) Instances[id];
			if(obj!=null) 
			{
				clone = (Custom)obj.Clone();
				session.AddUninitializedEntity( new Key(id, this), clone, LockMode.None );
				session.PostHydrate( this, id, new string[] {obj.Name}, clone, LockMode.None );
				session.InitializeEntity(clone);
			}
			return clone;

		}

		/// <summary>
		/// Hydrate the state of an object from the SQL <c>IDataReader</c>, into
		/// an array of "hydrated" values (do not resolve associations yet),
		/// and pass the hydrated state to the session.
		/// </summary>
		private void LoadFromResultSet(
			IDataReader rs,
			int i,
			object obj,
			System.Type instanceClass,
			EntityKey key,
			LockMode lockMode,
			ILoadable rootPersister,
			ISessionImplementor session)
		{
			object id = key.Identifier;

			// Get the persister for the _subclass_
			ILoadable persister = (ILoadable) Factory.GetEntityPersister(instanceClass);

			if (log.IsDebugEnabled)
			{
				log.Debug("Initializing object from DataReader: " + MessageHelper.InfoString(persister, id));
			}

			// add temp entry so that the next step is circular-reference
			// safe - only needed because some types don't take proper
			// advantage of two-phase-load (esp. components)
			session.AddUninitializedEntity(key, obj, lockMode);

			// This is not very nice (and quite slow):
			string[][] cols = persister == rootPersister ?
			                  EntityAliases[i].SuffixedPropertyAliases :
			                  EntityAliases[i].GetSuffixedPropertyAliases(persister);

			object[] values = Hydrate(
				rs,
				id,
				obj,
				persister,
				session,
				cols);

			// TODO H3:
//			IAssociationType[] ownerAssociationTypes = OwnerAssociationTypes;
//
//			if ( ownerAssociationTypes != null && ownerAssociationTypes[i] != null ) 
//			{
//				string ukName = ownerAssociationTypes[i].RHSUniqueKeyPropertyName;
//				if (ukName!=null) 
//				{
//					int index = ( (IUniqueKeyLoadable) persister ).GetPropertyIndex(ukName);
//					IType type = persister.PropertyTypes[index];
//	
//					// polymorphism not really handled completely correctly,
//					// perhaps...well, actually its ok, assuming that the
//					// entity name used in the lookup is the same as the
//					// the one used here, which it will be
//	
//					EntityUniqueKey euk = new EntityUniqueKey( 
//						rootPersister.MappedClass, //polymorphism comment above
//						ukName,
//						type.SemiResolve( values[ index ], session, obj ),
//						type,
//						session.EntityMode, session.Factory
//						);
//					session.AddEntity( euk, obj );
//				}
//			}

			session.PostHydrate(persister, id, values, obj, lockMode);
		}