Enterprise library manage connections

I am building an application with c# and I decided to use the Enterprise Library for the DAL (SQL Server).

I don't remember where, but I had read an article about EntLib which said that the connections are closed automatically.

Is it true?

If not, what is the best approach of managing the connections in the middle layer? Open and close in each method?

The above is a sample method of how I am using the EntLib

public DataSet ReturnSomething
{
    var sqlStr = "select something";
    DbCommand cmd = db.GetSqlStringComman开发者_如何学运维d(sqlStr);
    db.AddInParameter(cmd, "@param1", SqlDbType.BigInt, hotelID);
    db.AddInParameter(cmd, "@param2", SqlDbType.NVarChar, date);
    return db.ExecuteDataSet(cmd);

}

Thanks in advance.

the ExecuteDataSet method returns a DataSet object that contains all the data. This gives you your own local copy. The call to ExecuteDataSet opens a connection, populates a DataSet, and closes the connection before returning the result

for more info:

http://msdn.microsoft.com/en-us/library/ff648933.aspx

I think you should have something like a static class used as a Façade which would provide the correct connection for your library subsystems.

public static class SystemFacade {
    // Used as a subsystem to which the connections are provided.
    private static readonly SystemFactory _systemFactory = new SystemFactory();

    public static IList<Customer> GetCustomers() {
        using (var connection = OpenConnection(nameOfEntLibNamedConnection))
            return _systemFactory.GetCustomers(connection);
    }

    public static DbConnection OpenConnection(string connectionName) {
        var connection = 
            // Read EntLib config and create a new connection here, and assure
            // it is opened before you return it.

        if (connection.State == ConnectionState.Closed)
            connection.Open();

        return connection;            
    }
}

internal class SystemFactory {
    internal IList<Customer> GetCustomers(DbConnection connection) {
        // Place code to get customers here.
    }
}

And using this code:

public class MyPageClass {
    private void DisplayCustomers() {
        GridView.DataSource = SystemFacade.GetCustomers();
    }
}

In this code sample, you have a static class that provides the functionalities and features of a class library. The Façade class is used to provide the user with all possible action, but you don't want to get a headache with what connection to use, etc. All you want is the list of customers out of the underlying datastore. Then, a call to GetCustomers will do it.

The Façade is an "intelligent" class that knows where to get the information from, so creates the connection accordingly and order the customers from the subsystem factory. The factory does what it is asked for, take the available connection and retrieve the customers without asking any further questions.

Does this help?

Yes, EntLib closes connections for you (actually it releases them back into the connection pool). That is the main reason why we originally started to use EntLib.

However, for all new development we have now gone on to use Entity Framework, we find that much more productive.