ADO.NET数据访问层

Question

I'm maintaining an existing C# application which uses classic ADO.NET as a data access technology.The existing code creates a new instance of the SqlConnection and SqlCommand objects EVERY single time some interaction with the database is required. To make things simpler I wrote a little class to simplify this process to prevemt code repetition but I'm not an expert at ADO.NET so I wanted to ask if you can review my code and let me know if I missed any ADO.NET best practices or if the code below may impact DB operations negatively in anyway:

using System;
using System.Data;
using System.Data.SqlClient;

namespace MyApp.DataAccess
{
    public class DataAccessLayer : IDisposable
    {
        private SqlConnection _connection = new SqlConnection();
        private SqlCommand _command = new SqlCommand();

        public string ConnectionString 
        {
            get { return DBConfig.ConnectionString; }
        }

        public SqlCommand Command 
        {
            get { return _command; }
            set { _command = value; }
        }

        public SqlConnection SQLConnection 
        {
            get
            {
                if(_connection == null || _connection.State == ConnectionState.Closed)
                {
                    _connection = new SqlConnection(ConnectionString);
                    _connection.Open();
                }
                return _connection;
            }
        }

        public void SetCommand(string commandText,CommandType commandType)
        {
            _command = new SqlCommand(commandText, SQLConnection);
            _command.CommandType = commandType;
        }

        public void Dispose()
        {
            if (_connection != null)
                _connection.Dispose();

            if (_command != null)
                _command.Dispose();
        }
    }
}

Answer 1

As Tim explained, I would rather code this with the using statement. This will automatically close and dispose your SqlConnection instance.

Take a look at this example here from the MSDN page about the SqlConnection class :

using (SqlConnection connection = new SqlConnection(connectionString))
    {
        connection.Open();
        // Do work here; connection closed on following line.
    }

And what model_dialog explained, is also correct. If you invoke the Open method on the SqlConnection class the framework will not necesserily really open a new connection.

Instead it will check whether there is already an appropiate connection available in the connection pool. It does this by checking the connection string. If it founds a suitable connection, the connection pool will just return this connection with almost no performance impact. The connection pool is a catching component for SqlConnections so to speak.

See here for more details: SQL Server Connection Pooling (ADO.NET)