Transactions And Exceptions

I am a novice with SQL, and I am failing to understand an aspect of Transactions.

The following is the code I have created, having referred to a handful of resources including MSDN documentation.

    public void CreateSection(Section section)
    {
        string sql =
            @"INSERT INTO sectiontable (nodeid, title)
              VALUES (@nodeid, @title)
              SELECT Scope_Identity() FROM sectiontable";
        SqlConnection connection = new SqlConnection(this.connectionString);
        SqlCommand command = new SqlCommand(sql, connection);
        command.Parameters.AddWithValue("@nodeid", section.Node.Id);
        command.Parameters.AddWithValue("@title", section.Title);

        connection.Open();
        SqlTransaction transaction = connection.BeginTransaction();
        try
        {
            command.Transaction = transaction;
            object result = command.ExecuteScalar();
            if (result == null)
                throw new DataException("Returned identity was invalid.");
            section.Id = Convert.ToInt32(result);
            transaction.Commit();
        }
        catch (Exception exception)
        {
            string message = "Could not create section.";
            try
            {
                transaction.Rollback();
                message += " Transaction was reversed.";
            }
            catch (SqlException booboo)
            {
                message += " An exception of type " + booboo.GetType();
                message += " occurred while attempting to roll back the transaction.";
            }
            // Note: DataAccessException below is a custom class.
            throw new DataAccessException(message, exception);
        }
        finally
        {
            connection.Close();
        }
    }
   
   
What seems clumsy is that we must have connection.Open() outside the try-catch block. The following cannot work, because the compiler notes the "Use of unassigned local variable 'transaction'" at the location shown below:

        SqlConnection connection = new SqlConnection(this.connectionString);
        SqlTransaction transaction;
        try
        {
            connection.Open();
            transaction = connection.BeginTransaction();
            // commands execute
            transaction.Commit();
        }
        catch (Exception exception)
        {
            transaction.Rollback(); // <-- Compiler notes use of unassigned variable.
                                    // (First testing the variable does not help.)
            // handle exception.
        }
        finally
        {
            connection.Close();
        }
       
       
The following also does not work, as the BeginTransaction() method must be called against an open connection.

        SqlConnection connection = new SqlConnection(this.connectionString);
        SqlTransaction transaction = connection.BeginTransaction();
        try
        {
            connection.Open();
            // commands execute
            transaction.Commit();
        }
        catch (Exception exception)
        {
            transaction.Rollback();
            // handle exception.
        }
        finally
        {
            connection.Close();
        }
       


So, in MSDN documentation, the connection.Open() method is called outside the try-catch block (as shown in my full code). Yet, that same documentation notes that this method can lead to two types of exceptions. So it seems that the use of transactions forces an exception-throwing method to be used outside of a try-catch block. My question, then: is this unavoidable?