C# ICriteria.AddOrder方法代码示例

 public ICriteria AddCriteria(ICriteria criteria)
 {
     if (m_order == SortFilter.Orders.ASC)
     {
         return criteria.AddOrder(NHibernate.Criterion.Order.Asc(m_fieldName));
     }
     else
     {
         return criteria.AddOrder(NHibernate.Criterion.Order.Desc(m_fieldName));
     }
 }

		/// <summary>
		/// Adds a collection of Order (sort by) specifiers to an ICriteria.
		/// </summary>
		/// <param name="criteria">The ICriteria that will be modified.</param>
		/// <param name="orders">The collection of Order specifiers.</param>
		internal static void AddOrdersToCriteria(ICriteria criteria, Order[] orders)
		{
			if (orders != null)
			{
				foreach (Order order in orders)
				{
					criteria.AddOrder(order);
				}
			}
		}

        /// <summary>
        /// 
        /// </summary>
        /// <param name="hibernateCriteria"></param>
        /// <param name="where"></param>
        /// <param name="orders"></param>
        private void AddCriteriaAndOrder(ICriteria hibernateCriteria, IEnumerable<ICriterion> where, IEnumerable<Order> orders)
        {
            foreach (ICriterion criterion in where)
            {
                hibernateCriteria.Add(criterion);
            }

            foreach (Order order in orders)
            {
                hibernateCriteria.AddOrder(order);
            }
        }

 private static void AddOrdersToCriteria(ICriteria criteria, IEnumerable<Order> orders)
 {
     if (orders != null)
     {
         foreach (Order order in orders)
         {
             criteria.AddOrder(order);
         }
     }
 }

        private static void GetOrder(Sort sort, ICriteria cr)
        {
            bool sortDir = sort.Direction == "ASC" ? true : false;
            Order order = null;

            if (sort.Column.IndexOf(".", StringComparison.OrdinalIgnoreCase) >= 0)
                order = new Order(sort.Column, sortDir);

            else
                order = new Order(string.Format("attendance.{0}", sort.Column), sortDir);

            cr.AddOrder(order);
        }

 private static void GetOrder(Sort sort, ICriteria cr)
 {
     bool sortDir = sort.Direction == "ASC" ? true : false;
     Order order = new Order(string.Format("dept.{0}", sort.Column), sortDir);
     cr.AddOrder(order);
 }

 public void setOrderBy(ref ICriteria icr)
 {
     icr.AddOrder(new Order("recInd", false));
     icr.AddOrder(new Order("recLevel", false));
     icr.AddOrder((new Order("hotelName",true)));
 }

 public static ICriteria OrderComplexSearch(IList<OrderCriteria> critList, ICriteria c)
 {
     foreach (OrderCriteria s in critList)
     {
         switch (s.Order)
         {
             case OrderType.ASC:
                 c.AddOrder(Order.Asc(s.PropertyName));
                 break;
             case OrderType.DESC:
                 c.AddOrder(Order.Desc(s.PropertyName));
                 break;
         }
     }
     return c;
 }

 private static void AddTimeOrdering(ICriteria criteria)
 {
     criteria.AddOrder(Order.Asc("Year"));
     criteria.AddOrder(Order.Asc("Quarter"));
     criteria.AddOrder(Order.Asc("Month"));
 }

 protected void setOrderby(ref ICriteria icr)
 {
     string orderbyName = WebUtil.GetParamAttr("orderbyName",null);
     if (orderbyName == null) return;
     string orderbyType = WebUtil.GetParamAttr("orderbyType", "desc");
     if (orderbyType == "desc") {
         icr.AddOrder(Order.Desc(orderbyName));
     }
     else if (orderbyType == "asc")
     {
         icr.AddOrder(Order.Asc(orderbyName));
     }
     else {
         icr.AddOrder(Order.Desc(orderbyName));
     }
 }

 public void setOrderBy(ref ICriteria icr)
 {
     icr.AddOrder(Order.Desc("recInd"));
     icr.AddOrder(Order.Desc("recLevel"));
     icr.AddOrder(Order.Desc("picURL"));
     icr.AddOrder(Order.Desc("brandName"));
 }

 public void OnEvent(ICriteria crit)
 {
     crit.AddOrder(order);
 }

 public void Get_OnCriteria(object sender, ICriteria criteria)
 {
     criteria.AddOrder(Order.Asc("Code"));
     //            ICriterion criterion = Restrictions.Eq("Name", "测试123");
     //            criteria.Add(criterion);
 }

 public void setOrderBy(ref ICriteria icr)
 {
     icr.AddOrder(Order.Desc("id"));
 }

 /// <summary>
 /// Initializes the session that will be used to enumerate
 /// </summary>
 private void InitSession()
 {
     _session = _sessionFactory.OpenSession();
     _session.FlushMode = FlushMode.Never;
     _tx = _session.BeginTransaction();
     try
     {
         //Handle the case of entity type (InitialLoad)
         if (_entityType != null)
         {
             _criteria = _session.CreateCriteria(_entityType);
             _criteria.SetCacheable(false);
             //If perform by id, add order to the criteria
             if (_performOrderById)
             {
                 IClassMetadata metadata = _sessionFactory.GetClassMetadata(_entityType);
                 string idPropName = metadata.IdentifierPropertyName;
                 if (idPropName != null)
                     _criteria.AddOrder(Order.Asc(idPropName));
             }
         }
         //Handle the case of Persistency.Query (GetEnumerator)
         else if (_persistencyQuery != null)
         {
             string select = _persistencyQuery.SqlQuery;
             _query = _session.CreateQuery(select);
             object[] preparedValues = _persistencyQuery.Parameters;
             if (preparedValues != null)
             {
                 for (int i = 0; i < preparedValues.Length; i++)
                 {
                     _query.SetParameter(i, preparedValues[i]);
                 }
             }
             _query.SetCacheable(false);
             _query.SetFlushMode(FlushMode.Never);
         }
         else throw new Exception("NHibernateDataEnumerator must receive an Entity Type or a Query");
     }
     catch(Exception ex)
     {
         if (_tx != null && _tx.IsActive)
             _tx.Rollback();
         if (_session.IsOpen)
             _session.Close();
         throw new Exception("Error while constructing an enumerator", ex);
     }
 }