C# IQuery.SetParameter方法代码示例

 private void SetParameters(IQuery query)
 {
     foreach (var parameter in NamedParameters)
     {
         query.SetParameter(parameter.Name, parameter.Value);
     }
 }

		protected override void SetQueryParameters(IQuery query)
		{
			int i = 0;
			
			foreach (object param in parameters)
			{
				query.SetParameter(i++, param);
			}
		}

		protected override void SetQueryParameters(IQuery query)
		{
			var i = 0;
			
			foreach (var param in parameters)
			{
				query.SetParameter(i++, param);
			}
		}

 public void OnEvent(IQuery query)
 {
     switch (ctorType)
     {
         case CtorType.PositionVal:
             query.SetParameter(position, val);
             break;
         case CtorType.PositionValType:
             query.SetParameter(position, val, type);
             break;
         case CtorType.NameVal:
             query.SetParameter(name, val);
             break;
         case CtorType.NameValType:
             query.SetParameter(name, val, type);
             break;
         default:
             throw new ShardedSessionException(
                 "Unknown ctor type in SetParameterEvent: " + ctorType);
     }
 }

        /// <summary>
        /// Apply the given name parameter to the given Query object.
        /// </summary>
        /// <param name="queryObject">The query object.</param>
        /// <param name="paramName">Name of the parameter</param>
        /// <param name="value">The value of the parameter</param>
        /// <param name="type">The NHibernate type of the parameter (or <code>null</code> if none specified)</param>
        public virtual void ApplyNamedParameterToQuery(IQuery queryObject, string paramName, object value, IType type)
        {

            if (value is ICollection)
            {
                if (type != null)
                {
                    queryObject.SetParameterList(paramName, (ICollection)value, type);
                }
                else
                {
                    queryObject.SetParameterList(paramName, (ICollection)value);
                }
            }
            else if (value is Object[])
            {

                //TODO investigate support for this conversion.
                if (type != null)
                {
                    queryObject.SetParameterList(paramName, (Object[])value, type);
                }
                else
                {
                    queryObject.SetParameterList(paramName, (Object[])value);
                }
            }
            else
            {
                if (type != null)
                {
                    queryObject.SetParameter(paramName, value, type);
                }
                else
                {
                    queryObject.SetParameter(paramName, value);
                }
            }
        }

		/// <summary>
		/// Fill all <see cref="IQuery"/> properties.
		/// </summary>
		/// <param name="q">The <see cref="IQuery"/>.</param>
		/// <remarks>
		/// Query properties are overriden/merged.
		/// </remarks>
		protected void SetQueryProperties(IQuery q)
		{
			q.SetMaxResults(selection.MaxRows)
				.SetFirstResult(selection.FirstRow)
				.SetCacheable(cacheable)
				.SetReadOnly(readOnly)
				.SetTimeout(selection.Timeout)
				.SetFlushMode(flushMode)
				.SetFetchSize(selection.FetchSize);
			if (!string.IsNullOrEmpty(comment))
				q.SetComment(comment);
			if (!string.IsNullOrEmpty(cacheRegion))
				q.SetCacheRegion(cacheRegion);
			if (resultTransformer != null)
				q.SetResultTransformer(resultTransformer);
			if (cacheMode.HasValue)
				q.SetCacheMode(cacheMode.Value);
			foreach (KeyValuePair<string, LockMode> mode in lockModes)
				q.SetLockMode(mode.Key, mode.Value);

			// Set AbstractQueryImpl property before set parameters
			AbstractQueryImpl aqi = q as AbstractQueryImpl;
			if (aqi != null)
				aqi.SetIgnoreUknownNamedParameters(shouldIgnoredUnknownNamedParameters);

			// Even if the probably that somebody use a mixed technique to set parameters 
			// (from POCO using SetProperties and using named parameter setters) here is a possible
			// difference between IQuery and DetachedQuery behaviour.
			// In IQuery we don't know who override a param value; in DetachedQuery the direct use of 
			// a named parameter setter override the param value set by SetProperties(POCO)
			foreach (object obj in optionalUntypeParams)
				q.SetProperties(obj);

			// Set untyped positional parameters
			foreach (KeyValuePair<int, object> pup in posUntypeParams)
				q.SetParameter(pup.Key, pup.Value);

			// Set untyped named parameters
			foreach (KeyValuePair<string, object> nup in namedUntypeParams)
				q.SetParameter(nup.Key, nup.Value);

			// Set untyped named parameters list
			foreach (KeyValuePair<string, ICollection> nulp in namedUntypeListParams)
				q.SetParameterList(nulp.Key, nulp.Value);

			// Set typed positional parameters
			foreach (KeyValuePair<int, TypedValue> pp in posParams)
				q.SetParameter(pp.Key, pp.Value.Value, pp.Value.Type);

			// Set typed named parameters
			foreach (KeyValuePair<string, TypedValue> np in namedParams)
				q.SetParameter(np.Key, np.Value.Value, np.Value.Type);

			// Set typed named parameters List
			foreach (KeyValuePair<string, TypedValue> nlp in namedListParams)
				q.SetParameterList(nlp.Key, (ICollection)nlp.Value.Value, nlp.Value.Type);
		}

 private static void SetTimePeriodParameters(IQuery q, TimePeriod period)
 {
     q.SetParameter("year", period.Year);
     q.SetParameter("yearRange", period.YearRange);
     q.SetParameter("quarter", period.Quarter);
     q.SetParameter("month", period.Month);
 }

 private static void SetGroupingParameters(IQuery q, Grouping grouping)
 {
     q.SetParameter("indicatorId", grouping.IndicatorId);
     q.SetParameter(ParameterSexId, grouping.SexId);
     q.SetParameter("ageId", grouping.AgeId);
 }

 /// <summary>
 /// Add this parameter to the <paramref name="query"/>.
 /// </summary>
 /// <param name="query">The query</param>
 /// <remarks>
 /// Is there a cleaner way to do this, without reflection or complex
 /// hierarchies?
 /// </remarks>
 public void Apply(IQuery query)
 {
     if (IsFlagged(ParameterFlags.Named))
     {
         if (IsFlagged(ParameterFlags.List))
         {
             if (Type != null)
                 query.SetParameterList(Name, (ICollection) Value, Type);
             else
                 query.SetParameterList(Name, (ICollection) Value);
         }
         else
         {
             if (Type != null)
                 query.SetParameter(Name, Value, Type);
             else
                 query.SetParameter(Name, Value);
         }
     }
     else if (IsFlagged(ParameterFlags.Positional))
     {
         if (IsFlagged(ParameterFlags.List))
         {
             throw new InvalidOperationException("Parameter lists can not be positional");
         }
         else
         {
             if (Type != null)
                 query.SetParameter(Position, Value, Type);
             else
                 query.SetParameter(Position, Value);
         }
     }
 }

        private void CreateParameter(ModelBindingContext context, IQuery crit)
        {
            int i = 0;
            foreach (string pName in AnotherParameterName)
            {
                string parameterName = NHModelBinder.CreateSubPropertyName(context.ModelName, pName);
                var strValu = (string) context.ValueProvider.GetValue(parameterName).ConvertTo(typeof (string));
                IType paramType = TypeFactory.Basic(AnotherParameterType[i]);
                if (paramType == null)
                    throw new ArgumentException("Nhibernate do not defined base type named " +
                                                AnotherParameterType[i]);

                object val = NHMappingHelper.ConvertStringToObject(strValu, paramType);
                crit.SetParameter(parameterName, val, paramType);
            }
        }

 private void AddGroupingParameters(Grouping grouping, IQuery q)
 {
     q.SetParameter("indicatorId", grouping.IndicatorId);
     q.SetParameter("startYear", grouping.BaselineYear);
     q.SetParameter("endYear", grouping.DataPointYear);
     q.SetParameter("sexId", grouping.SexId);
     q.SetParameter("ageId", grouping.AgeId);
 }

 public void SetParameterValue(IQuery query)
 {
     query.SetParameter(flatEntityPropertyName, value);
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="query"></param>
        private void AddParameters(IQuery query)
        {
            if (!string.IsNullOrEmpty(txtNP1.Text) && !string.IsNullOrEmpty(txtPar1.Text))
            {
                query.SetParameter(txtNP1.Text , txtPar1.Text);
            }

            if (!string.IsNullOrEmpty(txtNP2.Text) && !string.IsNullOrEmpty(txtPar2.Text))
            {
                query.SetParameter(txtNP2.Text, txtPar2.Text);
            }

            if (!string.IsNullOrEmpty(txtNP3.Text) && !string.IsNullOrEmpty(txtPar3.Text))
            {
                query.SetParameter(txtNP3.Text, txtPar3.Text);
            }
        }

 /// <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);
     }
 }

        /// <summary>
        /// 向 IQuery 添加参数
        /// </summary>
        /// <param name="query"></param>
        private void AddParameters(IQuery query)
        {
            foreach (var item in filters)
            {
                if (!item.NoAdd && item.PropertyType == "ARR")
                    query.SetParameterList(item.PlaceholderPropertyName, item.PropertyValue as object[]);
                else if (!item.NoAdd)
                {
                    //query.SetParameter(item.PlaceholderPropertyName, item.PropertyValue);

                    if (item.Operation == "BT")
                    {
                        string[] valarr = item.PropertyValue.ToString().Split('_');
                        query.SetParameter(item.PlaceholderPropertyName + "_0", ValueConverter.Convert(item.PropertyType, valarr[0]));
                        query.SetParameter(item.PlaceholderPropertyName + "_1", ValueConverter.Convert(item.PropertyType, valarr[1]));
                    }
                    else
                    {
                        query.SetParameter(item.PlaceholderPropertyName, ValueConverter.Convert(item.PropertyType, item.PropertyValue));
                    }
                }
            }
        }