C# ICriteria.GetRootEntityTypeIfAvailable方法代码示例

        public static Type GetRootType(ICriteria criteria)
        {
            Type rootType = criteria.GetRootEntityTypeIfAvailable();
            if (rootType != null)
            {
                return rootType;
            }

            CriteriaImpl impl = GetRootCriteria(criteria);
            if(impl.Session==null)
                throw new InvalidOperationException("Could not get root type on criteria that is not attached to a session");

            ISessionFactoryImplementor factory = impl.Session.Factory;
            IEntityPersister persister = factory.GetEntityPersister(impl.EntityOrClassName);
            if (persister == null)
                throw new InvalidOperationException("Could not find entity named: " + impl.EntityOrClassName);

            return persister.GetMappedClass(EntityMode.Poco);
        }

        /// <summary>
        /// Add the Fetch clauses to the query according to the given expand paths, using the ICriteria API
        /// </summary>
        /// <param name="criteria">The query to expand</param>
        /// <param name="expandPaths">The names of the properties to expand.  May include nested paths of the form "Property/SubProperty"</param>
        /// <param name="sessionFactory">Provides the NHibernate metadata for the classes</param>
        /// <param name="expandMap">If provided, will be populated with the names of the expanded properties for each type.</param>
        /// <returns></returns>
        public static ICriteria ApplyExpansions(ICriteria criteria, string[] expandPaths, ISessionFactory sessionFactory, IDictionary<Type, List<string>> expandMap = null)
        {
            if (criteria == null) throw new ArgumentException("Criteria cannot be null");

            if (!expandPaths.Any()) throw new ArgumentException("Expansion Paths cannot be null");

            foreach (string expand in expandPaths)
            {
                // We always start with the resulting element type
                var currentType = criteria.GetRootEntityTypeIfAvailable();
                var dotpath = expand.Replace('/', '.');
                criteria.SetFetchMode(dotpath, FetchMode.Eager);

                // Add the types and properties to the expandMap so they will be serialized
                foreach (string seg in expand.Split('/'))
                {
                    if (expandMap != null && !expandMap.ContainsKey(currentType))
                        expandMap.Add(currentType, new List<string>());

                    IClassMetadata metadata = sessionFactory.GetClassMetadata(currentType);
                    if (metadata == null)
                    {
                        throw new ArgumentException("Type '" + currentType + "' not recognized as a valid type for this Context");
                    }

                    // Gather information about the property
                    var propInfo = currentType.GetProperty(seg);

                    if (propInfo == null)
                    {
                        throw new ArgumentException("Type '" + currentType.Name + "' does not have property '" + seg + "'");
                    }
                    if (expandMap != null) expandMap[currentType].Add(seg);
                    var propType = propInfo.PropertyType;

                    currentType = propType;
                }
            }

            return criteria;
        }

        /// <summary>
        /// To the future.
        /// </summary>
        /// <param name="criteria">The criteria.</param>
        /// <returns>IEnumerable.</returns>
        public static IEnumerable ToFuture(ICriteria criteria)
        {
            Type collectionType;
            try
            {
                collectionType = criteria.GetRootEntityTypeIfAvailable() ?? typeof(object);
            }
            catch (Exception)
            {
                collectionType = typeof(object);
            }

            FutureFunction current = Functions.FirstOrDefault(n => n.CollectionType == collectionType);
            if (current == null)
            {
                current = new FutureFunction(collectionType);
                Functions.Add(current);
            }

            return current.ExecuteFuture(criteria);
        }

 private string GetSecurityKeyProperty(ICriteria criteria)
 {
     Type rootType = criteria.GetRootEntityTypeIfAvailable();
     return criteria.Alias + "." + Security.GetSecurityKeyProperty(rootType);
 }