Using statement variations

Question

I found that my codebase contains various data access code where I have used using statements in two different ways. Which is the better way if any and are these two methods different? Any problems that could arise from not instantiating the SqlConnection and SqlCommand in the using statement? Ignore the obvious inconsistency problem.

Method 1:

public int SampleScalar(string query, CommandType queryType, SqlParameter[] parameters)
    {
        int returnValue = 0;
        SqlConnection objConn = new SqlConnection(ConnString);
        SqlCommand objCmd = new SqlCommand(query, objConn);
        objCmd.CommandType = queryType;

        if (parameters.Length > 0)
            objCmd.Parameters.AddRange(parameters);

        using (objConn)
        {
            using (objCmd)
            {
                objConn.Open();
                try
                {
                    returnValue = (int)objCmd.ExecuteScalar();
                }
                catch (SqlException e)
                {
                    Errors.handleSqlException(e, objCmd);
                    throw;
                }
            }
        }
        return returnValue;
    }

Method 2:

public int SampleScalar2(string query, CommandType queryType, SqlParameter[] parameters)
    {
        int returnValue = 0;
        using (SqlConnection objConn = new SqlConnection(ConnString))
        {
            using (SqlCommand objCmd = new SqlCommand(query, objConn))
            {
                objConn.Open();
                objCmd.CommandType = queryType;

                if (parameters.Length > 0)
                    objCmd.Parameters.AddRange(parameters);
                try
                {
                    returnValue = (int)objCmd.ExecuteScalar();
                }
                catch (SqlException e)
                {
                    Errors.handleSqlException(e, objCmd);
                    throw;
                }
            }
        }
        return returnValue;
    }

Answer 1

In the first snippet, if there are any exceptions that occur after the IDisposable object is created and before the start of the using, then it won't be properly disposed. With the second implementation, there is no such gap that could result in unreleased resources.

Another problem that can occur with the first approach is that you could use an object after it has been disposed, which is not likely to end well.

It's possible that you are ensuring no exception could possibly occur, and maybe you're not. In general, I would never use the first method simply because I don't trust myself (or anyone else) to never ever ever make a mistake in that unprotected space. If nothing else, I'll need to spend time and effort looking very closely to be sure that nothing can ever go wrong. You don't really gain anything from using that less-safe method either.