C# DbCommand.CreateParameter方法代码示例

        private void AddPagingParams(DbCommand cmd)
        {
            var sp = cmd.CreateParameter();
            Provider.SetupParameter(sp, SkipParameterName, _skip);
            cmd.Parameters.Add(sp);

            var tp = cmd.CreateParameter();
            Provider.SetupParameter(tp, TakeParameterName, _take);
            cmd.Parameters.Add(tp);
            var lc = new List<string>(ParamNames);
            lc.Add(SkipParameterName);
            lc.Add(TakeParameterName);
            ParamNames = lc.ToArray();
        }

        protected void SetupParameters(DbCommand cmd)
        {
            ParamNames = new string[0];
            if (_args.Length > 0)
            {
                var paramDict = CreateParamsDictionary(_args);
                var allp = cmd.Parameters;
                List<string> pnames = new List<string>();
                StringBuilder sb =null;
                var lastParamCount = _args.Length;

                IDbDataParameter p = null;

                foreach (var kv in paramDict)
                {
                    if (kv.Value.IsListParam())
                    {
                        if (sb == null)
                        {
                            sb = new StringBuilder();
                        }
                        else sb.Clear();
                        
                        var listParam = kv.Value as IEnumerable;
                        
                        foreach (var val in listParam)
                        {
                            p = cmd.CreateParameter();

                            sb.Append("@" + lastParamCount + ",");
                            pnames.Add(lastParamCount.ToString());
                            Provider.SetupParameter(p, lastParamCount.ToString(), val);
                            allp.Add(p);
                            lastParamCount++;
                        }
                        sb.Remove(sb.Length - 1, 1);
                        _sql = _sql.Replace("@" + kv.Key, sb.ToString());
                    }
                    else
                    {
                        p = cmd.CreateParameter();
                        Provider.SetupParameter(p, kv.Key, kv.Value);
                        pnames.Add(kv.Key);
                        allp.Add(p);
                    }
                }

                ParamNames = pnames.ToArray();
            }
        }

 public static DbParameter CreateParameter(DbCommand cmd, string name, DbType type)
 {
     DbParameter param = cmd.CreateParameter();
     param.ParameterName = name;
     param.DbType = type;
     return param;
 }

        /// <summary>
        /// Creates a new parameter and adds it to the command's Parameters collection.
        /// </summary>
        /// <param name="command">The command that the parameter will be added to.</param>
        /// <param name="parameterName">The parameter name.</param>
        public ParameterChainMethods(DbCommand command, string parameterName, object value)
        {
            Parameter = command.CreateParameter();
            Parameter.ParameterName = parameterName;

            // Convert null to DBNull.Value
            if (value == null) 
                value = DBNull.Value;

            Type valueType = value.GetType();

            // Check for a registered IConverter
            IConverter converter = MapRepository.Instance.GetConverter(valueType);
            if (converter != null)
            {
                Parameter.Value = converter.ToDB(value);
            }
            else
            {
                Parameter.Value = value;
            } 

            //// Determine the correct DbType based on the passed in value type
            //IDbTypeBuilder typeBuilder = MapRepository.Instance.DbTypeBuilder;
            //Enum dbType = typeBuilder.GetDbType(valueType);

            //// Set the appropriate DbType property depending on the parameter type
            //typeBuilder.SetDbType(Parameter, dbType);

            command.Parameters.Add(Parameter);
        }

 private static void AddParameter(DbCommand cmd, string name, object value)
 {
     var p = cmd.CreateParameter();
     p.ParameterName = name;
     p.Value = value ?? DBNull.Value;
     cmd.Parameters.Add(p);
 }

        /// <summary>
        /// Add the specified arguments to the specified command.
        /// </summary>
        /// <param name="cmd">
        /// The command that will receive the arguments.
        /// </param>
        /// <param name="args">The arguments to add.</param>
        private void AddCommandParameters(DbCommand cmd, params object[] args)
        {
            if (args != null)
            {
                int count = cmd.Parameters.Count;

                for (int i = 0; i < args.Length; i++)
                {
                    object value = args[i];

                    if (value != null)
                    {
                        if (value is Guid)
                        {
                            value = value.ToString();
                        }
                    }

                    if (count > i)
                    {
                        cmd.Parameters[i].Value = value;
                    }
                    else
                    {
                        DbParameter param = cmd.CreateParameter();
                        param.Value = value;
                        cmd.Parameters.Add(param);
                    }
                }
            }
        }

 public DbParameter GetParameter(DbCommand cmd, string name, object value)
 {
     var p = cmd.CreateParameter();
     p.ParameterName = name;
     p.Value = value == null ? DBNull.Value : value;
     return p;
 }

 /// <summary>
 /// The assign parameters.
 /// </summary>
 /// <param name="command">
 /// The command.
 /// </param>
 /// <param name="parameterValues">
 /// The parameter values.
 /// </param>
 public void AssignParameters(DbCommand command, object[] parameterValues)
 {
     DbParameter parameter = command.CreateParameter();
     parameter.ParameterName = "@Id";
     parameter.Value = parameterValues[0];
     command.Parameters.Add(parameter);
 }

        private static DbCommand CreateCommandImpl(DbCommandBuilder commandBuilder, DbCommand command, string commandText, params object[] parameters)
        {

            if (commandBuilder == null) throw new ArgumentNullException("commandBuilder");
            if (command == null) throw new ArgumentNullException("command");
            if (commandText == null) throw new ArgumentNullException("commandText");

            if (parameters == null || parameters.Length == 0)
            {
                command.CommandText = commandText;
                return command;
            }

            object[] paramPlaceholders = new object[parameters.Length];

            for (int i = 0; i < paramPlaceholders.Length; i++)
            {

                DbParameter dbParam = command.CreateParameter();
                dbParam.ParameterName = getParameterName(commandBuilder, i);
                dbParam.Value = parameters[i] ?? DBNull.Value;
                command.Parameters.Add(dbParam);

                paramPlaceholders[i] = getParameterPlaceholder(commandBuilder, i);
            }

            command.CommandText = String.Format(CultureInfo.InvariantCulture, commandText, paramPlaceholders);

            return command;
        }

 protected void AddParam(ref DbCommand cmd, string paramName)
 {
     DbParameter Parm;
     Parm = cmd.CreateParameter();
     Parm.ParameterName = paramName;
     cmd.Parameters.Add(Parm);
 }

        private static IEnumerable<DbParameter> createParameters(DbCommand cmd, string commandText, params object[] paramValues)
        {
            if (string.IsNullOrEmpty(commandText)) return null;
            if (paramValues == null || paramValues.Length == 0) return null;
            var coll = new List<DbParameter>();

            var idx = commandText.IndexOf("@", StringComparison.CurrentCultureIgnoreCase);
            if (idx == -1)
                return null;

            var parmString = commandText.Substring(idx);
            parmString = parmString.Replace(",", " ,");
            var mc = RegEx.Matches(parmString);

            var matchesList = removeDuplicates(mc);

            if (matchesList.Count != paramValues.Length)
                throw new ArgumentOutOfRangeException("paramValues");

            for (var i = 0; i < matchesList.Count; i++)
            {
                DbParameter parm = cmd.CreateParameter();
                parm.ParameterName = matchesList[i];
                parm.Value = paramValues[i] ?? DBNull.Value;
                coll.Add(parm);
            }

            return coll;
        }

 public static void AddWithValue(ref DbCommand command, string parameterName, object parameterValue)
 {
     var parameter = command.CreateParameter();
     parameter.ParameterName = parameterName;
     parameter.Value = parameterValue;
     command.Parameters.Add(parameter);
 }

 protected virtual void AddInput(DbCommand dbCommand, String name, Object value)
 {
     DbParameter dbParameter = dbCommand.CreateParameter();
     dbParameter.Direction = ParameterDirection.Input;
     dbParameter.ParameterName = name;
     dbParameter.Value = (value == null ? DBNull.Value : value);
     dbCommand.Parameters.Add(dbParameter);
 }

 public static void AddInParameter(DbCommand cmd, string paramName, DbType type, object value)
 {
     DbParameter param = cmd.CreateParameter();
     param.Value = (value == null) ? DBNull.Value : value;
     param.DbType = type;
     param.ParameterName = paramName;
     cmd.Parameters.Add(param);
 }

 public void AddReturnParameter(DbCommand cmd, string parameterName, DbType dbType)
 {
     DbParameter dbParameter = cmd.CreateParameter();
     dbParameter.DbType = dbType;
     dbParameter.ParameterName = parameterName;
     dbParameter.Direction = ParameterDirection.ReturnValue;
     cmd.Parameters.Add(dbParameter);
 }