帮我看看using用的怎么样

Question

public int ReturnExcuteScalar(string strSQL, SqlParameter[] param)
        {
            using (SqlConnection conn = new SqlConnection(Dbstr.connstr))
            {
                using (SqlCommand cmd = new SqlCommand())
                {
                    if (conn.State.Equals(ConnectionState.Closed))
                    {
                        conn.Open();
                    }
                    try
                    {
                        cmd.CommandType = CommandType.Text ;
                        cmd.Connection = conn;
                        cmd.CommandText = strSQL;                        foreach (SqlParameter parameter in param)
                        {
                            if (parameter != null)
                            {
                                cmd.Parameters.Add(parameter);
                            }
                        }
                        int count = (int)cmd.ExecuteScalar();
                        return count;
                    }
                    catch (Exception e)
                    {
                        throw e;
                    }
                    finally
                    {
                        cmd.Dispose();
                        conn.Close();
                    }
                }
            }
        }
以上代码是否写的有缺陷，帮忙参考一下、或是不合理的地方

Answer 1

你连using用法的用途都没搞清楚你这里用using和没用一个样，一点意义都没有

Answer 2

你是想在对象使用完毕后释放资源吗？
SqlCommand 没必要吧？

Answer 3

这个写法不恰当先解释一下using：使用using关键字是可以在using达到末尾是自动释放对象也可以在到达 using 语句的末尾之前引发了异常并且控制权离开语句块时，退出using 语句。这就是说你的代码这样写完全是正确，编译器不会报错不恰当在：
1.完全可以不用using，因为你自己使用的try-catch-finally，可以很好的垃圾回收2.异常有可以能发生于你程序中的下列代码
          if (conn.State.Equals(ConnectionState.Closed))
         {
             conn.Open();//发生异常，退出了using而未释放对象
         }3.使用using的目的在于是程序简练
public int ReturnExcuteScalar(string strSQL, SqlParameter[] param)
        {
            int i_result = 0;
             
            using (SqlConnection conn = new SqlConnection(Dbstr.connstr))
            {
                conn.Open();
                using (SqlCommand cmd = conn.CreateCommand())
                {
                        cmd.CommandType = CommandType.Text ;
                        cmd.Connection = conn;
                        cmd.CommandText = strSQL;                        foreach (SqlParameter parameter in param)
                        {
                            if (parameter != null)
                            {
                                cmd.Parameters.Add(parameter);
                            }
                        }
                        int count = (int)cmd.ExecuteScalar();
                        i_result = count;
                        //return count; 检测不到
                }                return i_result;
            }
        }

Answer 4

finally
                    {
                        cmd.Dispose();
                        conn.Close();
                    }
你既然在finally里面关闭了连接释放了资源，那外面还要加using干啥？

Answer 5

finally
                    {
                        cmd.Dispose();
                        conn.Close();
                    }
发现这段代码没有用

Answer 6

补充一句，发生的异常由外部调用的对象去扑捉，一般的异常就不要随便抛出了                try
                {
                    int i = ReturnExcuteScalar(obj, objs);
                }
                catch (Exception ex)
                {
                    ex.Message;
                }

Answer 7

哈哈，知道了，但是int i_result = 0;这个为什么非要从新声明一个呢，我的代码也可以运行的//return count; 检测不到什么啊。。

Answer 8

 public static int ExecuteSqlByTime(string SQLString, int Times)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        cmd.CommandTimeout = Times;
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                    finally
                    {
                        cmd.Dispose();
                        connection.Close();
                    }
                }
            }
        }这段代码是李开平老师写的。哎自学真费劲啊。。搞得一塌糊涂

Answer 9

using 语句的功能应该 是 保证资源得到 在 使用完毕之后得到释放，也就是说，在我们没有用代码释放掉资源的时候，using语句可以保证释放掉资源
当然是using()，（）中的资源。

Answer 10

所以我不太同意5楼的观点，说using是为了程序的简练

Answer 11

我这不是书里面的，是李开平老师提供的一个三层结构源代码的程序，不过这种写法是一种，有的带finally。有的不带，很多种，搞得我分不清楚了。   /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                    finally
                    {
                        cmd.Dispose();
                        connection.Close();
                    }
                }
            }
        }        public static int ExecuteSqlByTime(string SQLString, int Times)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        cmd.CommandTimeout = Times;
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                    finally
                    {
                        cmd.Dispose();
                        connection.Close();
                    }
                }
            }
        } public static int ExecuteSqlTran(List<String> SQLStringList)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();
                SqlCommand cmd = new SqlCommand();
                cmd.Connection = connection;
                SqlTransaction tx = connection.BeginTransaction();
                cmd.Transaction = tx;
                try
                {
                    int count = 0;
                    for (int n = 0; n < SQLStringList.Count; n++)
                    {
                        string strsql = SQLStringList[n];
                        if (strsql.Trim().Length > 1)
                        {
                            cmd.CommandText = strsql;
                            count += cmd.ExecuteNonQuery();
                        }
                    }
                    tx.Commit();
                    return count;
                }
                catch
                {
                    tx.Rollback();
                    return 0;
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }
        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, string content)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                SqlCommand cmd = new SqlCommand(SQLString, connection);
                System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
                myParameter.Value = content;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.SqlClient.SqlException e)
                {
                    throw e;
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }/// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string SQLString)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                    finally
                    {
                        cmd.Dispose();
                        connection.Close();
                    }
                }
            }
        }
        public static object GetSingle(string SQLString, int Times)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        cmd.CommandTimeout = Times;
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                    finally
                    {
                        cmd.Dispose();
                        connection.Close();
                    }
                }
            }
        }

Answer 12

using (SqlCommand cmd = new SqlCommand())有了这个了为什么还要用cmd.Dispose()?????看来LZ对using还是不太了解。

Answer 13

 if (conn.State.Equals(ConnectionState.Closed))
                    {
                        conn.Open();
                    }
看到这里，就不需要再看了。

Answer 14

为程序的返回声明一个变量(var)，在程序的末尾return var;是一种比较好的编程习惯，过多的使用return，会让代码看上去比较混乱 

Answer 15

用了using就没必要再手动释放资源了！