C# DbProviderFactory.CreateParameter方法代码示例

 internal static DbParameter CreateParameter(DbProviderFactory factory,
     Action<DbParameter> setup)
 {
     DbParameter parameter = factory.CreateParameter();
     setup(parameter);
     return parameter;
 }

        private static object CreateObject(DbProviderFactory factory, ProviderSupportedClasses kindOfObject, string providerName)
        {
            switch (kindOfObject)
            {
                case ProviderSupportedClasses.DbConnection:
                    return factory.CreateConnection();

                case ProviderSupportedClasses.DbDataAdapter:
                    return factory.CreateDataAdapter();

                case ProviderSupportedClasses.DbParameter:
                    return factory.CreateParameter();

                case ProviderSupportedClasses.DbCommand:
                    return factory.CreateCommand();

                case ProviderSupportedClasses.DbCommandBuilder:
                    return factory.CreateCommandBuilder();

                case ProviderSupportedClasses.DbDataSourceEnumerator:
                    return factory.CreateDataSourceEnumerator();

                case ProviderSupportedClasses.CodeAccessPermission:
                    return factory.CreatePermission(PermissionState.None);
            }
            throw new InternalException(string.Format(CultureInfo.CurrentCulture, "Cannot create object of provider class identified by enum {0} for provider {1}", new object[] { Enum.GetName(typeof(ProviderSupportedClasses), kindOfObject), providerName }));
        }

        //public static DbParameter CreateParameter(this DbProviderFactory dbFactory, string parameterName, object value)
        /// <summary>
        /// Create a DbParameter with the specified name and value.
        /// </summary>
        public static DbParameter CreateParameter(DbProviderFactory dbFactory, string parameterName, object value)
        {
            if (dbFactory == null) throw new ArgumentNullException("dbFactory");

            var parameter = dbFactory.CreateParameter();
            parameter.ParameterName = parameterName;
            parameter.Value = value;
            return parameter;
        }

        /// <summary>
        /// Método que cria e retorna um parâmetro DbParameter do tipo da DbFactory da tag AppSettings do web.config.
        /// </summary>
        /// <param name="_nome">Nome do parâmetro.</param>
        /// <param name="_valor">Valor do parâmetro.</param>
        /// <param name="_tipo">Tipo do parâmetro (DbType).</param>
        public static DbParameter Parametro(string _nome, object _valor, DbType _tipo)
        {
            factory = DBConnectionProvider.GetDbFactory();
            DbParameter parameter = factory.CreateParameter();

            parameter.ParameterName = _nome;
            parameter.Value  = _valor;
            parameter.DbType = _tipo;

            return parameter;
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="command"></param>
 /// <param name="factory"></param>
 /// <param name="type"></param>
 /// <param name="name"></param>
 /// <param name="value"></param>
 public static void AddParameterToCommand(
     DbCommand command,
     DbProviderFactory factory,
     System.Data.DbType type,
     String name,
     object value)
 {
     DbParameter param = factory.CreateParameter();
     param.DbType = type;
     param.ParameterName = GetParameterName(command, name);
     param.Value = value;
     command.Parameters.Add(param);
 }

 private void AddCommandInitStatements(IList statements, CodeExpression commandExpression, DbSourceCommand command, DbProviderFactory currentFactory, bool isFunctionsDataComponent)
 {
     if (((statements == null) || (commandExpression == null)) || (command == null))
     {
         throw new InternalException("Argument should not be null.");
     }
     Type parameterType = currentFactory.CreateParameter().GetType();
     Type type = currentFactory.CreateCommand().GetType();
     CodeExpression parameterVariable = null;
     statements.Add(CodeGenHelper.Assign(commandExpression, CodeGenHelper.New(CodeGenHelper.GlobalType(type), new CodeExpression[0])));
     if (isFunctionsDataComponent)
     {
         commandExpression = CodeGenHelper.Cast(CodeGenHelper.GlobalType(type), commandExpression);
     }
     if ((((DbSource) command.Parent).Connection == null) || ((this.designTable.Connection != null) && (this.designTable.Connection == ((DbSource) command.Parent).Connection)))
     {
         statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(commandExpression, "Connection"), CodeGenHelper.Property(CodeGenHelper.This(), DataComponentNameHandler.DefaultConnectionPropertyName)));
     }
     else
     {
         Type type3 = currentFactory.CreateConnection().GetType();
         IDesignConnection connection = ((DbSource) command.Parent).Connection;
         CodeExpression propertyReference = null;
         if (connection.PropertyReference == null)
         {
             propertyReference = CodeGenHelper.Str(connection.ConnectionStringObject.ToFullString());
         }
         else
         {
             propertyReference = connection.PropertyReference;
         }
         statements.Add(CodeGenHelper.Assign(CodeGenHelper.Property(commandExpression, "Connection"), CodeGenHelper.New(CodeGenHelper.GlobalType(type3), new CodeExpression[] { propertyReference })));
     }
     statements.Add(QueryGeneratorBase.SetCommandTextStatement(commandExpression, command.CommandText));
     statements.Add(QueryGeneratorBase.SetCommandTypeStatement(commandExpression, command.CommandType));
     if (command.Parameters != null)
     {
         foreach (DesignParameter parameter in command.Parameters)
         {
             parameterVariable = QueryGeneratorBase.AddNewParameterStatements(parameter, parameterType, currentFactory, statements, parameterVariable);
             statements.Add(CodeGenHelper.Stm(CodeGenHelper.MethodCall(CodeGenHelper.Property(commandExpression, "Parameters"), "Add", new CodeExpression[] { parameterVariable })));
         }
     }
 }

        private void UpdateNotify(Post post, DbConnection conn, DbProviderFactory provider)
        {
            string sqlQuery = "DELETE FROM " + tablePrefix + "PostNotify WHERE PostID = " + parmPrefix + "id";
            using (DbCommand cmd = conn.CreateCommand())
            {
                cmd.CommandText = sqlQuery;
                cmd.CommandType = CommandType.Text;
                DbParameter dpID = provider.CreateParameter();
                dpID.ParameterName = parmPrefix + "id";
                dpID.Value = post.Id.ToString();
                cmd.Parameters.Add(dpID);
                cmd.ExecuteNonQuery();

                foreach (string email in post.NotificationEmails)
                {
                    cmd.CommandText = "INSERT INTO " + tablePrefix + "PostNotify (PostID, NotifyAddress) " +
                        "VALUES (" + parmPrefix + "id, " + parmPrefix + "notify)";
                    cmd.Parameters.Clear();
                    DbParameter dpPostID = provider.CreateParameter();
                    dpPostID.ParameterName = parmPrefix + "id";
                    dpPostID.Value = post.Id.ToString();
                    cmd.Parameters.Add(dpPostID);
                    DbParameter dpNotify = provider.CreateParameter();
                    dpNotify.ParameterName = parmPrefix + "notify";
                    dpNotify.Value = email;
                    cmd.Parameters.Add(dpNotify);

                    cmd.ExecuteNonQuery();
                }
            }
        }

        private void UpdateCategories(Post post, DbConnection conn, DbProviderFactory provider)
        {
            string sqlQuery = "DELETE FROM " + tablePrefix + "PostCategory WHERE PostID = " + parmPrefix + "id";
            using (DbCommand cmd = conn.CreateCommand())
            {
                cmd.CommandText = sqlQuery;
                cmd.CommandType = CommandType.Text;
                DbParameter dpID = provider.CreateParameter();
                dpID.ParameterName = parmPrefix + "id";
                dpID.Value = post.Id.ToString();
                cmd.Parameters.Add(dpID);
                cmd.ExecuteNonQuery();

                foreach (Category cat in post.Categories)
                {
                    cmd.CommandText = "INSERT INTO " + tablePrefix + "PostCategory (PostID, CategoryID) " +
                        "VALUES (" + parmPrefix + "id, " + parmPrefix + "cat)";
                    cmd.Parameters.Clear();
                    DbParameter dpPostID = provider.CreateParameter();
                    dpPostID.ParameterName = parmPrefix + "id";
                    dpPostID.Value = post.Id.ToString();
                    cmd.Parameters.Add(dpPostID);
                    DbParameter dpCat = provider.CreateParameter();
                    dpCat.ParameterName = parmPrefix + "cat";
                    dpCat.Value = cat.Id.ToString();
                    cmd.Parameters.Add(dpCat);

                    cmd.ExecuteNonQuery();
                }
            }
        }

        private void addBlogRollParametersToCommand(BlogRollItem blogRollItem, DbProviderFactory provider, DbCommand cmd)
        {
            DbParameter dpID = provider.CreateParameter();
            dpID.ParameterName = parmPrefix + "BlogRollId";
            dpID.Value = blogRollItem.Id.ToString();
            cmd.Parameters.Add(dpID);

            DbParameter dpTitle = provider.CreateParameter();
            dpTitle.ParameterName = parmPrefix + "Title";
            dpTitle.Value = blogRollItem.Title;
            cmd.Parameters.Add(dpTitle);

            DbParameter dpDesc = provider.CreateParameter();
            dpDesc.ParameterName = parmPrefix + "Description";
            dpDesc.Value = blogRollItem.Description;
            cmd.Parameters.Add(dpDesc);

            DbParameter dpBlogUrl = provider.CreateParameter();
            dpBlogUrl.ParameterName = "BlogUrl";
            dpBlogUrl.Value = blogRollItem.BlogUrl != null ? (object)blogRollItem.BlogUrl.ToString() : DBNull.Value;
            cmd.Parameters.Add(dpBlogUrl);

            DbParameter dpFeedUrl = provider.CreateParameter();
            dpFeedUrl.ParameterName = "FeedUrl";
            dpFeedUrl.Value = blogRollItem.FeedUrl != null ? (object)blogRollItem.FeedUrl.ToString() : DBNull.Value;
            cmd.Parameters.Add(dpFeedUrl);

            DbParameter dpXfn = provider.CreateParameter();
            dpXfn.ParameterName = "Xfn";
            dpXfn.Value = blogRollItem.Xfn;
            cmd.Parameters.Add(dpXfn);

            DbParameter dpSortIndex = provider.CreateParameter();
            dpSortIndex.ParameterName = "SortIndex";
            dpSortIndex.Value = blogRollItem.SortIndex;
            cmd.Parameters.Add(dpSortIndex);
        }

        /// <summary>
        /// The update tags.
        /// </summary>
        /// <param name="post">
        /// The post to update.
        /// </param>
        /// <param name="conn">
        /// The connection.
        /// </param>
        /// <param name="provider">
        /// The provider.
        /// </param>
        private void UpdateTags(Post post, DbConnection conn, DbProviderFactory provider)
        {
            var sqlQuery = string.Format("DELETE FROM {0}PostTag WHERE PostID = {1}id", this.tablePrefix, this.parmPrefix);
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandText = sqlQuery;
                cmd.CommandType = CommandType.Text;
                var id = provider.CreateParameter();
                if (id != null)
                {
                    id.ParameterName = string.Format("{0}id", this.parmPrefix);
                    id.Value = post.Id.ToString();
                    cmd.Parameters.Add(id);
                }

                cmd.ExecuteNonQuery();

                foreach (var tag in post.Tags)
                {
                    cmd.CommandText = string.Format("INSERT INTO {0}PostTag (PostID, Tag) VALUES ({1}id, {2}tag)", this.tablePrefix, this.parmPrefix, this.parmPrefix);
                    cmd.Parameters.Clear();
                    var postId = provider.CreateParameter();
                    if (postId != null)
                    {
                        postId.ParameterName = string.Format("{0}id", this.parmPrefix);
                        postId.Value = post.Id.ToString();
                        cmd.Parameters.Add(postId);
                    }

                    var tag2 = provider.CreateParameter();
                    if (tag2 != null)
                    {
                        tag2.ParameterName = string.Format("{0}tag", this.parmPrefix);
                        tag2.Value = tag;
                        cmd.Parameters.Add(tag2);
                    }

                    cmd.ExecuteNonQuery();
                }
            }
        }

        /// <summary>
        /// The update notify.
        /// </summary>
        /// <param name="post">
        /// The post to update.
        /// </param>
        /// <param name="conn">
        /// The connection.
        /// </param>
        /// <param name="provider">
        /// The provider.
        /// </param>
        private void UpdateNotify(Post post, DbConnection conn, DbProviderFactory provider)
        {
            var sqlQuery = string.Format("DELETE FROM {0}PostNotify WHERE PostID = {1}id", this.tablePrefix, this.parmPrefix);
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandText = sqlQuery;
                cmd.CommandType = CommandType.Text;
                var id = provider.CreateParameter();
                if (id != null)
                {
                    id.ParameterName = string.Format("{0}id", this.parmPrefix);
                    id.Value = post.Id.ToString();
                    cmd.Parameters.Add(id);
                }

                cmd.ExecuteNonQuery();

                foreach (var email in post.NotificationEmails)
                {
                    cmd.CommandText = string.Format("INSERT INTO {0}PostNotify (PostID, NotifyAddress) VALUES ({1}id, {2}notify)", this.tablePrefix, this.parmPrefix, this.parmPrefix);
                    cmd.Parameters.Clear();
                    var postId = provider.CreateParameter();
                    if (postId != null)
                    {
                        postId.ParameterName = string.Format("{0}id", this.parmPrefix);
                        postId.Value = post.Id.ToString();
                        cmd.Parameters.Add(postId);
                    }
                    var notify = provider.CreateParameter();
                    if (notify != null)
                    {
                        notify.ParameterName = string.Format("{0}notify", this.parmPrefix);
                        notify.Value = email;
                        cmd.Parameters.Add(notify);
                    }

                    cmd.ExecuteNonQuery();
                }
            }
        }

        /// <summary>
        /// The update comments.
        /// </summary>
        /// <param name="post">
        /// The post to update.
        /// </param>
        /// <param name="conn">
        /// The connection.
        /// </param>
        /// <param name="provider">
        /// The provider.
        /// </param>
        private void UpdateComments(Post post, DbConnection conn, DbProviderFactory provider)
        {
            var sqlQuery = string.Format("DELETE FROM {0}PostComment WHERE PostID = {1}id", this.tablePrefix, this.parmPrefix);
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandText = sqlQuery;
                cmd.CommandType = CommandType.Text;
                var id = provider.CreateParameter();
                if (id != null)
                {
                    id.ParameterName = string.Format("{0}id", this.parmPrefix);
                    id.Value = post.Id.ToString();
                    cmd.Parameters.Add(id);
                }

                cmd.ExecuteNonQuery();

                foreach (var comment in post.Comments)
                {
                    sqlQuery = string.Format("INSERT INTO {0}PostComment (PostCommentID, ParentCommentID, PostID, CommentDate, Author, Email, Website, Comment, Country, Ip, IsApproved, ModeratedBy, Avatar, IsSpam, IsDeleted) VALUES (@postcommentid, @parentid, @id, @date, @author, @email, @website, @comment, @country, @ip, @isapproved, @moderatedby, @avatar, @isspam, @isdeleted)", this.tablePrefix);
                    if (this.parmPrefix != "@")
                    {
                        sqlQuery = sqlQuery.Replace("@", this.parmPrefix);
                    }

                    cmd.CommandText = sqlQuery;
                    cmd.Parameters.Clear();
                    var commentId = provider.CreateParameter();
                    if (commentId != null)
                    {
                        commentId.ParameterName = string.Format("{0}postcommentid", this.parmPrefix);
                        commentId.Value = comment.Id.ToString();
                        cmd.Parameters.Add(commentId);
                    }

                    var parentId = provider.CreateParameter();
                    if (parentId != null)
                    {
                        parentId.ParameterName = string.Format("{0}parentid", this.parmPrefix);
                        parentId.Value = comment.ParentId.ToString();
                        cmd.Parameters.Add(parentId);
                    }

                    var postId = provider.CreateParameter();
                    if (postId != null)
                    {
                        postId.ParameterName = string.Format("{0}id", this.parmPrefix);
                        postId.Value = post.Id.ToString();
                        cmd.Parameters.Add(postId);
                    }

                    var dpCommentDate = provider.CreateParameter();
                    dpCommentDate.ParameterName = this.parmPrefix + "date";
                    dpCommentDate.Value = comment.DateCreated.AddHours(-BlogSettings.Instance.Timezone);
                    cmd.Parameters.Add(dpCommentDate);

                    var dpAuthor = provider.CreateParameter();
                    dpAuthor.ParameterName = this.parmPrefix + "author";
                    dpAuthor.Value = comment.Author;
                    cmd.Parameters.Add(dpAuthor);

                    var dpEmail = provider.CreateParameter();
                    dpEmail.ParameterName = this.parmPrefix + "email";
                    dpEmail.Value = comment.Email ?? string.Empty;
                    cmd.Parameters.Add(dpEmail);

                    var dpWebsite = provider.CreateParameter();
                    if (dpWebsite != null)
                    {
                        dpWebsite.ParameterName = string.Format("{0}website", this.parmPrefix);
                        dpWebsite.Value = comment.Website == null ? string.Empty : comment.Website.ToString();
                        cmd.Parameters.Add(dpWebsite);
                    }

                    var dpContent = provider.CreateParameter();
                    dpContent.ParameterName = this.parmPrefix + "comment";
                    dpContent.Value = comment.Content;
                    cmd.Parameters.Add(dpContent);

                    var dpCountry = provider.CreateParameter();
                    dpCountry.ParameterName = this.parmPrefix + "country";
                    dpCountry.Value = comment.Country ?? string.Empty;
                    cmd.Parameters.Add(dpCountry);

                    var dpIP = provider.CreateParameter();
                    dpIP.ParameterName = this.parmPrefix + "ip";
                    dpIP.Value = comment.IP ?? string.Empty;
                    cmd.Parameters.Add(dpIP);
//.........这里部分代码省略.........

        /// <summary>
        /// The update categories.
        /// </summary>
        /// <param name="post">
        /// The post to update.
        /// </param>
        /// <param name="conn">
        /// The connection.
        /// </param>
        /// <param name="provider">
        /// The provider.
        /// </param>
        private void UpdateCategories(Post post, DbConnection conn, DbProviderFactory provider)
        {
            var sqlQuery = string.Format("DELETE FROM {0}PostCategory WHERE PostID = {1}id", this.tablePrefix, this.parmPrefix);
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandText = sqlQuery;
                cmd.CommandType = CommandType.Text;
                var id = provider.CreateParameter();
                if (id != null)
                {
                    id.ParameterName = string.Format("{0}id", this.parmPrefix);
                    id.Value = post.Id.ToString();
                    cmd.Parameters.Add(id);
                }

                cmd.ExecuteNonQuery();

                foreach (var cat in post.Categories)
                {
                    cmd.CommandText = string.Format("INSERT INTO {0}PostCategory (PostID, CategoryID) VALUES ({1}id, {2}cat)", this.tablePrefix, this.parmPrefix, this.parmPrefix);
                    cmd.Parameters.Clear();
                    var postId = provider.CreateParameter();
                    if (postId != null)
                    {
                        postId.ParameterName = string.Format("{0}id", this.parmPrefix);
                        postId.Value = post.Id.ToString();
                        cmd.Parameters.Add(postId);
                    }

                    var category = provider.CreateParameter();
                    if (category != null)
                    {
                        category.ParameterName = string.Format("{0}cat", this.parmPrefix);
                        category.Value = cat.Id.ToString();
                        cmd.Parameters.Add(category);
                    }

                    cmd.ExecuteNonQuery();
                }
            }
        }

 private static CodeExpression BuildNewSqlCeParameterStatement(DesignParameter parameter, DbProviderFactory factory)
 {
     SqlDbType type = SqlDbType.Char;
     bool flag = false;
     if ((parameter.ProviderType != null) && (parameter.ProviderType.Length > 0))
     {
         try
         {
             type = (SqlDbType) Enum.Parse(typeof(SqlDbType), parameter.ProviderType);
             flag = true;
         }
         catch
         {
         }
     }
     Type componentType = null;
     object component = factory.CreateParameter();
     if (component != null)
     {
         componentType = component.GetType();
     }
     if (!flag && (component != null))
     {
         PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(componentType);
         if (properties != null)
         {
             PropertyDescriptor descriptor = properties["DbType"];
             if (descriptor != null)
             {
                 descriptor.SetValue(component, parameter.DbType);
                 type = (SqlDbType) descriptor.GetValue(component);
             }
         }
     }
     return NewParameter(parameter, componentType, typeof(SqlDbType), type.ToString());
 }

 internal static DbParameter CreateParameter(DbProviderFactory factory)
 {
     return factory.CreateParameter();
 }