有木有向数据库添加数据的通用类。

Question

有木有向数据库添加数据的通用类。

Answer 1

获得DBHelper，网上很多这样的工具类，搜索一下就可以找到很多。

Answer 2

http://topic.csdn.net/u/20121015/08/c78078e9-d1a3-4252-b0e3-3d59dc946eca.html?1942

Answer 3

数据库操作类sqlhelper
EF
自己编写

Answer 4

我的意思是不管什么项目，只要是保存数据，都可以调用，不用每次都insert

Answer 5

我有，自己写的 一个 ，要的话我就给你 贴出来 或是你自己去 下个 SQLHELPER。每个数据库的语法都不一样。还有就是 组件的 DLL 也不一样。需要 整合的。你可以自己写一个 所有的 都用 接口 ，这样 不管是 oledbConnection 还是 Mysql 还是 sqlserver就都可以了 

Answer 6

这个可以不？//ExecuteNonQuery
        public static int ExecuteNonQuery(string sql, params SqlParameter[] parameters)//
        {
            string connStr = ConfigurationManager.ConnectionStrings["ConnStr"].ConnectionString;
            using (SqlConnection conn = new SqlConnection(connStr))
            {
                conn.Open();    //打开数据库
                using (SqlCommand cmd = conn.CreateCommand
                {
                    cmd.CommandText = sql;
                    foreach (SqlParameter param in parameters)
                    {
                        cmd.Parameters.Add(param);
                    }
                    return cmd.ExecuteNonQuery();
                }
            }
        }
SQLHelper.ExecuteNonQuery("update Login set ErrorTimes = ErrorTimes + 1 where Users = @user", new SqlParameter("user", txtUser.Text));
可以直接调用的。。

Answer 7

ORM类的框架都可以做到啊。你自己写一个简单sqlhelper的也不难的

Answer 8

[code=csharp]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Data;
using System.Configuration;namespace RMS_DBUtility
{
    public class DBHelper : IDBHelper
    {
        //单例对象
        private static DBHelper helper = null;
        //SQL数据连接
        //private SqlConnection conn;
        //SQL命令对象
        //  private SqlCommand cmd;
        //SQL数据适配器
        //private SqlDataAdapter sda;        #region GetInstance
        /// <summary>
        /// 获取helper对象
        /// </summary>
        /// <returns>DBHelper</returns>
        public static DBHelper GetInstance()
        {
            if (helper == null)
            {
                helper = new DBHelper();
            }
            return helper;
        }
        #endregion
        #region 私有方法
        /// <summary>
        /// 得到SQL数据连接对象
        /// </summary>
        /// <returns>SqlConnection</returns>
        private SqlConnection GetConnection()
        {            SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["connString"].ConnectionString);            //conn = new SqlConnection("server=16.173.247.175;uid=sa;pwd=sa;database=EVOC");
            conn.Open();
            return conn;
        }        /// <summary>
        /// 自定义得到SQL数据连接对象
        /// </summary>
        /// <param name="connStr">自定义得到SQL数据连接</param>
        /// <returns>SqlConnection</returns>
        private SqlConnection GetConnection(string connStr)
        {            SqlConnection conn = new SqlConnection(connStr);            //conn = new SqlConnection("server=16.173.247.175;uid=sa;pwd=sa;database=EVOC");
            conn.Open();
            return conn;
        }        /// <summary>
        /// 关闭SQL数据连接
        /// </summary>
        /// <param name="conn">SqlConnection</param>
        private void CloseConnection(SqlConnection conn)
        {
            if (conn != null && conn.State == ConnectionState.Open)
            {
                conn.Close();
            }
        }        /// <summary>
        /// 为命令对象设置参数
        /// </summary>
        /// <param name="parameters">参数列表</param>
        private void SetParameter(SqlParameter[] parameters, SqlCommand cmd)
        {
            cmd.CommandTimeout = 999;
            //如果参数不为空并且至少有一个参数则为命令对象添加参数
            if (parameters != null && parameters.Length > 0)
            {
                foreach (SqlParameter param in parameters)
                {
                    cmd.Parameters.Add(param);
                }
            }
        }
        #endregion        public int ExcuteSQLNonQuery(string sql, SqlParameter[] parameters)
        {
            //影响行数
            int count = 0;
            //获取数据连接
            SqlConnection conn = GetConnection();
            //创建命令对象
            SqlCommand cmd = new SqlCommand(sql, conn);
            //设置命令事务
            SqlTransaction transaction = conn.BeginTransaction();
            cmd.Transaction = transaction;
            SetParameter(parameters, cmd);
            try
            {
                count = cmd.ExecuteNonQuery();
                transaction.Commit();
            }
            catch (Exception ex)
            {
                transaction.Rollback();
                throw ex;
            }
            finally
            {
                CloseConnection(conn);
            }
            return count;
        }        public int ExcuteProcNonQuery(string procName, SqlParameter[] parameters)
        {
            int count = 0;
            SqlConnection conn = GetConnection();
            SqlCommand cmd = new SqlCommand(procName, conn);
            cmd.CommandType = CommandType.StoredProcedure;
            SqlTransaction transaction = conn.BeginTransaction();
            cmd.Transaction = transaction;
            SetParameter(parameters, cmd);
            try
            {
                count = cmd.ExecuteNonQuery();
                transaction.Commit();
            }
            catch (Exception ex)
            {
                transaction.Rollback();
                throw ex;
            }
            finally
            {
                CloseConnection(conn);
            }
            return count;
        }        public SqlDataReader ExcuteSQLReader(string sql, SqlParameter[] parameters)
        {
            SqlDataReader sdr = null;
            SqlConnection conn = GetConnection();
            try
            {
                SqlCommand cmd = new SqlCommand(sql, conn);
                SetParameter(parameters, cmd);
                sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                CloseConnection(conn);
                throw ex;
            }
            return sdr;        }        public SqlDataReader ExcuteProcReader(string procName, SqlParameter[] parameters)
        {
            SqlDataReader sdr = null;
            SqlConnection conn = GetConnection();
            try
            {
                SqlCommand cmd = new SqlCommand(procName, conn);
                cmd.CommandType = CommandType.StoredProcedure;                SetParameter(parameters, cmd);
                sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                CloseConnection(conn);
                throw ex;
            }
            return sdr;
        }        /// <summary>
        /// over load function 
        /// </summary>
        /// <param name="procName"></param>
        /// <param name="parameters"></param>
        /// <param name="connStr">connection string</param>
        /// <returns></returns>
        public SqlDataReader ExcuteProcReader(string procName, SqlParameter[] parameters, string connStr)
        {
            SqlDataReader sdr = null;
            SqlConnection conn = GetConnection(connStr);
            try
            {
                SqlCommand cmd = new SqlCommand(procName, conn);
                cmd.CommandType = CommandType.StoredProcedure;                SetParameter(parameters, cmd);
                sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                CloseConnection(conn);
                throw ex;
            }
            return sdr;
        }
        public DataTable ExcuteProcReader(string procName, SqlParameter[] parameters, out int count)
        {
            DataTable dt = new DataTable();
            SqlConnection conn = GetConnection();
            try
            {
                SqlCommand cmd = new SqlCommand(procName, conn);
                cmd.CommandType = CommandType.StoredProcedure;
                SetParameter(parameters, cmd);
                using (SqlDataAdapter sda = new SqlDataAdapter(cmd))
                {
                    sda.Fill(dt);
                    count = Convert.ToInt32(sda.SelectCommand.Parameters[parameters.Length - 1].Value);
                }
            }
            catch (Exception ex)
            {
                count = 0;
                throw ex;
            }
            finally
            {
                CloseConnection(conn);
            }
            return dt;
        }
        public DataTable ExcuteProcReader(string procName, SqlParameter[] parameters, out int count, string connStr)
        {
            DataTable dt = new DataTable();
            SqlConnection conn = GetConnection(connStr);
            try
            {
                SqlCommand cmd = new SqlCommand(procName, conn);
                cmd.CommandType = CommandType.StoredProcedure;
                SetParameter(parameters, cmd);
                using (SqlDataAdapter sda = new SqlDataAdapter(cmd))
                {
                    sda.Fill(dt);
                    count = Convert.ToInt32(sda.SelectCommand.Parameters[parameters.Length - 1].Value);
                }
            }
            catch (Exception ex)
            {
                count = 0;
                throw ex;
            }
            finally
            {
                CloseConnection(conn);
            }
            return dt;
        }

Answer 9

和上面链接起的        public DataTable ExcuteProcTable(string procName, SqlParameter[] parameters)
        {
            DataTable dt = new DataTable();
            SqlConnection conn = GetConnection();
            try
            {
                SqlCommand cmd = new SqlCommand(procName, conn);
                cmd.CommandType = CommandType.StoredProcedure;
                SetParameter(parameters, cmd);
                using (SqlDataAdapter sda = new SqlDataAdapter(cmd))
                {
                    sda.Fill(dt);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                CloseConnection(conn);
            }
            return dt;
        }        public bool ExcuteProcs(Dictionary<string, SqlParameter[]> procs)
        {
            bool flag = false;
            SqlConnection conn = GetConnection();
            SqlCommand cmd = new SqlCommand();
            cmd.CommandType = CommandType.StoredProcedure;
            cmd.Connection = conn;
            SqlTransaction transaction = conn.BeginTransaction();
            cmd.Transaction = transaction;
            try
            {
                foreach (string procName in procs.Keys)
                {
                    cmd.CommandText = procName;
                    if (procName.LastIndexOf(".") != -1)
                    {
                        cmd.CommandText = procName.Substring(0, procName.LastIndexOf("."));
                    }
                    cmd.Parameters.Clear();
                    SetParameter(procs[procName], cmd);
                    cmd.ExecuteNonQuery();
                }
                transaction.Commit();
                flag = true;
            }
            catch (Exception ex)
            {
                transaction.Rollback();
                throw ex;
            }
            finally
            {
                CloseConnection(conn);
            }
            return flag;
        }
    }
}直接调用就可以了：
SqlDataReader dr = helper.ExcuteProcReader("[proc_search_P6_Project_List_PageData]", sp)
[/code]

Answer 10

http://www.cnblogs.com/jonneydong/archive/2010/05/29/2418719.html
带执行示例