谁能帮我解释一下这段代码什么意思

Question

/// <summary>
/// 保护变量，数据库连接。
/// </summary>
protected SqlConnection Connection;
/// <summary>
/// 保护变量，数据库连接串。
/// </summary>
        protected static String ConnectionString;
/// <summary>
/// 保护方法，打开数据库连接。
/// </summary>
protected void Open() 
{
if (Connection == null)
{
try
{
Connection = new SqlConnection(ConnectionString);
}
catch(Exception e)
{
log.WriteLog(EventLogEntryType.Error,"创建数据库连接失败，系统异常信息："+e.Message);
}
}
if (Connection.State.Equals(ConnectionState.Closed))
{
try
{
Connection.Open();
}
catch(Exception e)
{
log.WriteLog(EventLogEntryType.Error,"打开数据库连接失败，系统异常信息："+e.Message);
}
}
}我是想写一个类，专门是对数据库的操作的，然后只要调用一下就可以用，但是我网上下下来好多这样的，但是不会用，直接调用还是怎么用，我很疑惑，谁能帮我理一下头绪

Answer 1

这个是open SqlConnection对象，数据库操作完了以后，要及时关闭这个对象。

Answer 2

这段代码里没有初始化ConnectionString，你可以在protected static String ConnectionString="你的数据库连接串"； 这样就可以了。

Answer 3

完整代码太大了，我还是不明白怎么样可以把弄成protected static String ConnectionString="你的数据库连接串"

Answer 4

SqlConnection.ConnectionString 属性获取或设置用于打开 SQL Server 数据库的字符串。
比如这样：ConnectionString = "Persist Security Info=False;Integrated Security=true;Initial Catalog=Northwind;server=(local)"

Answer 5

http://msdn.microsoft.com/zh-cn/library/system.data.sqlclient.sqlconnection.connectionstring.aspx

Answer 6

只要设置一下SqlConnection.ConnectionString就可以了？

Answer 7

我给你写个完整点，你创建一个类名字叫DBHelper
里边写一个静态字符串private static string conStr="server="服务器";database="数据库";uid=sa;pwd="密码""
再写一个静态方法返回连接字符串 public static sqlConnection GetConstr()
{
   return new SqlConnection(conStr);
}然后在你的那个需要连接数据库的类里面实例化一个字符串来接收返回的字符串。比如
string conStr=DBHelper.GetConstr();
接着
sqlconnnection con=new sqlconnnection（conStr）；
con.open（）;
。。
往下就是sql语句，不用我继续了吧！

Answer 8

protected static String ConnectionString ="Data Source=主机地址;Initial Catalog=数据库名;User ID=用户;Password=密码"；

Answer 9

public static string GetConnection()
        {
            string strConnection = clsConfig.GetConfig();//这里我用的是读写XML，你可以写死
            return strConnection;
        }        public static bool blnConnection(string strConn)
        {
            SqlConnection conn = new  SqlConnection(strConn);
            try
            {
                conn.Open();
                conn.Close();
                return true;
            }
            catch
            {
                return false;
            }
        } public void TransBegin()
        {
            try
            {
                if (this.conn.State != ConnectionState.Open)
                {
                    this.conn.Open();
                }
                if (this.trans != null)
                {
                    this.trans = null;
                }
                this.trans = this.conn.BeginTransaction();
            }
            catch (SqlException SQLE)
            {
                throw SQLE;
            }
            catch (Exception EXP)
            {
                throw EXP;
            }
        }        public void TransCommit()
        {
            try
            {
                if (this.trans != null)
                {
                    this.trans.Commit();
                    this.conn.Close();
                }
            }
            catch (SqlException SQLE)
            {
                throw SQLE;
            }
            catch (Exception EXP)
            {
                throw EXP;
            }
        }        public void TransRollback()
        {
            try
            {
                if (this.trans != null)
                {
                    this.trans.Rollback();
                    this.conn.Close();
                }
            }
            catch (SqlException SQLE)
            {
                throw SQLE;
            }
            catch (Exception EXP)
            {
                throw EXP;
            }
        }        public string cmdExecuteScalar(string strSQL)
        {
            try
            {
                object obj = null;
                cmd = new SqlCommand(strSQL, conn);
                if (conn.State != ConnectionState.Open)
                {
                    conn.Open();
                }
                if (this.trans != null)
                {
                    cmd.Transaction = trans;
                    obj = cmd.ExecuteScalar();
                }
                else
                {
                    obj = cmd.ExecuteScalar();
                    conn.Close();
                }
                if (obj == null)
                {
                    return "";
                }
                else
                {
                    return obj.ToString();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }        public DataSet GetDataSet(string strSQL)
        {
            try
            {
                SqlDataAdapter da = new SqlDataAdapter(strSQL, conn);
                cmd = new SqlCommand(strSQL, conn);
                da.SelectCommand = cmd;
                if (trans != null)
                {
                    cmd.Transaction = trans;
                    ds = new DataSet();
                    da.Fill(ds);
                }
                else
                {
                    ds = new DataSet();
                    da.Fill(ds);
                }
                return ds;
            }
            catch (Exception ex)
            {
                return null;
            }
        }        public void cmdExecuteNonQuery(string strSQL)
        {
            SqlCommand cmd = new SqlCommand(strSQL, conn);
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }
            if (this.trans != null)
            {
                cmd.Transaction = trans;
                cmd.ExecuteNonQuery();
            }
            else
            {
                cmd.ExecuteNonQuery();
                conn.Close();
            }
        }        public SqlDataReader GetSQLDataReader(string strSQL)
        {
            SqlDataReader dr;
            try
            {
                SqlCommand cmd = new SqlCommand(strSQL, conn);
                if (conn.State != ConnectionState.Open)
                {
                    conn.Open();
                }
                dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                return dr;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }这几个应该够你用了