private static void CheckEntityMode(EntityMode entityMode)
		{
			if (EntityMode.Poco != entityMode)
			{
				throw new ArgumentOutOfRangeException("entityMode", "Unhandled EntityMode : " + entityMode);
			}
		}

        public static Type FindType(string clazz, ISession session, EntityMode entityMode) {
            if(IsDebugEnabled)
                log.Debug("인스턴싱할 엔티티 형식을 찾습니다... clazz=[{0}], entityMode=[{1}]", clazz, entityMode);

            var result = session.SessionFactory.GetEntityType(clazz, entityMode);

            if(result != null) {
                // lock(_syncLock)
                return _entityTypeCache.GetOrAdd(clazz, result);
            }

            foreach(var assembly in AppDomain.CurrentDomain.GetAssemblies()) {
                result = assembly.GetType(clazz, false, true);

                if(result != null) {
                    return _entityTypeCache.GetOrAdd(clazz, result);
                    //lock(_syncLock)
                    //    _entityTypeCache.AddValue(clazz, result);

                    //return result;
                }
            }

            return _entityTypeCache.GetOrAdd(clazz, result);
        }

        public override object Instantiate(string clazz, EntityMode entityMode, object id)
        {
            if (entityMode == EntityMode.Poco)
            {
                Type type = this.typeResolver.ResolveType(clazz);

                if (type != null)
                {
                    if (type.GetConstructors().Any(constructor => constructor.GetParameters().Any()))
                    {
                        try
                        {
                            object instance = ObjectFactory.GetInstance(type);

                            this.session.SessionFactory
                                    .GetClassMetadata(clazz)
                                    .SetIdentifier(instance, id, entityMode);
                            return instance;
                        }
                        catch (Exception exception)
                        {
                            Console.WriteLine(exception);
                        }
                    }
                }
            }

            return base.Instantiate(clazz, entityMode, id);
        }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="entity">an actual entity object, not a proxy!</param>
		/// <param name="entityMode"></param>
		/// <returns></returns>
		public string ToString(object entity, EntityMode entityMode)
		{
			IClassMetadata cm = _factory.GetClassMetadata(entity.GetType());
			if (cm == null)
			{
				return entity.GetType().FullName;
			}

			IDictionary<string, string> result = new Dictionary<string, string>();

			if (cm.HasIdentifierProperty)
			{
				result[cm.IdentifierPropertyName] =
					cm.IdentifierType.ToLoggableString(cm.GetIdentifier(entity, entityMode), _factory);
			}

			IType[] types = cm.PropertyTypes;
			string[] names = cm.PropertyNames;
			object[] values = cm.GetPropertyValues(entity, entityMode);

			for (int i = 0; i < types.Length; i++)
			{
				var value = values[i];
				if (Equals(LazyPropertyInitializer.UnfetchedProperty, value) || Equals(BackrefPropertyAccessor.Unknown, value))
				{
					result[names[i]] = value.ToString();
				}
				else
				{
					result[names[i]] = types[i].ToLoggableString(value, _factory);
				}
			}

			return cm.EntityName + CollectionPrinter.ToString(result);
		}

		/// <summary> 
		/// Locate the contained tuplizer responsible for the given entity-mode.  If
		/// no such tuplizer is defined on this mapping, then return null. 
		/// </summary>
		/// <param name="entityMode">The entity-mode for which the caller wants a tuplizer. </param>
		/// <returns> The tuplizer, or null if not found. </returns>
		public virtual ITuplizer GetTuplizerOrNull(EntityMode entityMode)
		{
			EnsureFullyDeserialized();
			ITuplizer result;
			_tuplizers.TryGetValue(entityMode, out result);
			return result;
		}

		public override bool IsEqual(object x, object y, EntityMode entityMode, ISessionFactoryImplementor factory)
		{
			IEntityPersister persister = factory.GetEntityPersister(associatedEntityName);
			if (!persister.CanExtractIdOutOfEntity)
			{
				return base.IsEqual(x, y, entityMode);
			}

			object xid;
			
			if (x.IsProxy())
			{
				INHibernateProxy proxy = x as INHibernateProxy; 
				xid = proxy.HibernateLazyInitializer.Identifier;
			}
			else
			{
				xid = persister.GetIdentifier(x, entityMode);
			}

			object yid;
			
			if (y.IsProxy())
			{
				INHibernateProxy proxy = y as INHibernateProxy; 
				yid = proxy.HibernateLazyInitializer.Identifier;
			}
			else
			{
				yid = persister.GetIdentifier(y, entityMode);
			}

			return persister.IdentifierType.IsEqual(xid, yid, entityMode, factory);
		}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="rootAlias"></param>
        /// <param name="rootType"></param>
        /// <param name="matchMode"></param>
        /// <param name="entityMode"></param>
        /// <param name="instance"></param>
        /// <param name="classInfoProvider"></param>
        public CriteriaCompiled(string rootAlias, System.Type rootType, MatchMode matchMode, EntityMode entityMode,
                                object instance, Func<System.Type, IPersistentClassInfo> classInfoProvider)
        {
            
            if (rootAlias == null || rootAlias.Trim().Equals(string.Empty))
                throw new ArgumentException("The alias for making detached criteria cannot be empty or null", "rootAlias");

            if (rootType == null)
                throw new ArgumentNullException("rootType", "The type which can be used for maikng detached criteria cannot be null.");

            if (instance == null)
                throw new ArgumentNullException("instance", "The instance for building detached criteria cannot be null.");

            if (!rootType.IsInstanceOfType(instance))
                throw new ArgumentTypeException("The given instance for building detached criteria is not suitable for the given criteria type.", "instance", rootType, instance.GetType());

            this.matchMode = matchMode ?? MatchMode.Exact;
            this.entityMode = entityMode;
            this.instance = instance;
            this.classInfoProvider = classInfoProvider;

            this.relationshipTree = new RelationshipTree(rootAlias, rootType);
            this.criteria = DetachedCriteria.For(rootType, rootAlias);
            this.restrictions = new List<ICriterion>();
            this.Init();
        }

		private object[] GetValues(object entity, EntityEntry entry, EntityMode entityMode, bool mightBeDirty, ISessionImplementor session)
		{
			object[] loadedState = entry.LoadedState;
			Status status = entry.Status;
			IEntityPersister persister = entry.Persister;

			object[] values;
			if (status == Status.Deleted)
			{
				//grab its state saved at deletion
				values = entry.DeletedState;
			}
			else if (!mightBeDirty && loadedState != null)
			{
				values = loadedState;
			}
			else
			{
				CheckId(entity, persister, entry.Id, entityMode);

				// grab its current state
				values = persister.GetPropertyValues(entity, entityMode);

				CheckNaturalId(persister, entry, values, loadedState, entityMode, session);
			}
			return values;
		}

		/// <summary>
		/// 
		/// </summary>
		/// <param name="entity">an actual entity object, not a proxy!</param>
		/// <param name="entityMode"></param>
		/// <returns></returns>
		public string ToString(object entity, EntityMode entityMode)
		{
			IClassMetadata cm = _factory.GetClassMetadata(entity.GetType());
			if (cm == null)
			{
				return entity.GetType().FullName;
			}

			IDictionary<string, string> result = new Dictionary<string, string>();

			if (cm.HasIdentifierProperty)
			{
				result[cm.IdentifierPropertyName] =
					cm.IdentifierType.ToLoggableString(cm.GetIdentifier(entity, entityMode), _factory);
			}

			IType[] types = cm.PropertyTypes;
			string[] names = cm.PropertyNames;
			object[] values = cm.GetPropertyValues(entity, entityMode);

			for (int i = 0; i < types.Length; i++)
			{
				result[names[i]] = types[i].ToLoggableString(values[i], _factory);
			}

			return cm.EntityName + CollectionPrinter.ToString(result);
		}

		/// <summary> 
		/// Construct a new key for a collection or entity instance.
		/// Note that an entity name should always be the root entity 
		/// name, not a subclass entity name. 
		/// </summary>
		/// <param name="id">The identifier associated with the cached data </param>
		/// <param name="type">The Hibernate type mapping </param>
		/// <param name="entityOrRoleName">The entity or collection-role name. </param>
		/// <param name="entityMode">The entity mode of the originating session </param>
		/// <param name="factory">The session factory for which we are caching </param>
		public CacheKey(object id, IType type, string entityOrRoleName, EntityMode entityMode, ISessionFactoryImplementor factory)
		{
			key = id;
			this.type = type;
			this.entityOrRoleName = entityOrRoleName;
			this.entityMode = entityMode;
			hashCode = type.GetHashCode(key, entityMode, factory);
		}

		public override object DeepCopy(object value, EntityMode entityMode, ISessionFactoryImplementor factory)
		{
			IExternalBlobConnection blobconn;
			byte[] identifier;
			if (this.ExtractLobData(value, out blobconn, out identifier))
				return CreateLobInstance(blobconn, identifier);
			return value;
		}

 private CollectionKey(string role, object key, IType keyType, EntityMode entityMode, ISessionFactoryImplementor factory)
 {
     this.role = role;
     this.key = key;
     this.keyType = keyType;
     this.entityMode = entityMode;
     this.factory = factory;
     hashCode = GenerateHashCode(); //cache the hashcode
 }

		/// <summary> Locate the tuplizer contained within this mapping which is responsible
		/// for the given entity-mode.  If no such tuplizer is defined on this
		/// mapping, then an exception is thrown.
		/// 
		/// </summary>
		/// <param name="entityMode">The entity-mode for which the caller wants a tuplizer.
		/// </param>
		/// <returns> The tuplizer.
		/// </returns>
		/// <throws>  HibernateException Unable to locate the requested tuplizer. </throws>
		public virtual ITuplizer GetTuplizer(EntityMode entityMode)
		{
			ITuplizer tuplizer = GetTuplizerOrNull(entityMode);
			if (tuplizer == null)
			{
				throw new HibernateException("No tuplizer found for entity-mode [" + entityMode + "]");
			}
			return tuplizer;
		}

		public FilterKey(string name, IEnumerable<KeyValuePair<string, object>> @params, IDictionary<string, IType> types, EntityMode entityMode)
		{
			filterName = name;
			foreach (KeyValuePair<string, object> me in @params)
			{
				IType type = types[me.Key];
				filterParameters[me.Key] = new TypedValue(type, me.Value, entityMode);
			}
		}

		public override int GetHashCode(object x, EntityMode entityMode)
		{
			int hashCode = base.GetHashCode(x, entityMode);
			unchecked
			{
				hashCode = 31*hashCode + ((DateTime) x).Kind.GetHashCode();
			}
			return hashCode;
		}

        public override Object Instantiate(String clazz, EntityMode entityMode, Object id)
        {
            if (entityMode != EntityMode.Poco)
                return base.Instantiate(clazz, entityMode, id);

            var classMetadata = _session.SessionFactory.GetClassMetadata(clazz);
            var entityType = classMetadata.GetMappedClass(entityMode);
            var entity = classMetadata.Instantiate(id, entityMode);
            return AddPropertyChangedInterceptorProxyFactory.Create(entityType, entity);
        }

		public override object Instantiate(string clazz, EntityMode entityMode, object id)
		{
			logger.Debug("Instantiate: " + clazz + " " + entityMode + " " + id);
		    object instance = interceptor.Create(clazz, id);
		    if (instance != null)
		    {
		        Session.SessionFactory.GetClassMetadata(clazz).SetIdentifier(instance, id, entityMode);
		    }
		    return instance;
		}

		private Type GetType(string clazz, EntityMode entityMode)
		{
			Type type = SessionFactory.GetClassMetadata(clazz)
										.GetMappedClass(entityMode);
			if (type == null)
			{
				throw new InvalidOperationException(string.Format("Cannot find the type {0}.", clazz));
			}
			return type;
		}

		public virtual object[] GetPropertyValues(object component, EntityMode entityMode)
		{
			int len = Subtypes.Length;
			object[] result = new object[len];
			for (int i = 0; i < len; i++)
			{
				result[i] = GetPropertyValue(component, i);
			}
			return result;
		}

        protected void Validate(object entity, EntityMode mode)
        {
            if (entity == null || mode != EntityMode.Poco)
                return;

            var validator = validatorFactory.GetValidator(entity.GetType());
            var result = validator != null ? validator.Validate(entity) : emptyValidationResult;
            if (!result.IsValid)
            {
                throw new ValidationException(result.Errors);
            }
        }