减少C＃中的使用次数

Question

My question might be silly or may not be a question at all, but here it goes..

I am performing quite some database operations in my ASP.net MVC project where I am creating two objects each and every time namely, SqlConnection and SqlCommand .

I have shown an example below

using (SqlConnection connection = new SqlConnection(connectionString))
{
  using (SqlCommand command = new SqlCommand("sRegisterUser", connection))
  {

I am doing all these different operations inside one class under different methods.

My question is how can I reduce the creation of these objects each and every time? How can I create them globally

PS: sRegisterUser is a stored procedure, like wise other methods use different procedures which gets different values as parameters.

Please help me out.

Thanks for any help in advance.

Answer 1

The answer is, don't. You do not want to share these objects, you are using them appropriately.

Answer 2

You don't. You either keep the object alive, which is bad. Or you dispose it the way you should, and currently do.

So, why do you have use using ?

Since using is necessary for disposing the handles in Windows.

You could also write this, which is similar to using using :

SqlConnection connection = new SqlConnection(connectionString);
connection.Close();
connection.Dispose();

using also disposes when the code above throws an error. Using using is actually the shortest way to code this.

So the error-save version should be:

SqlConnection connection;

try
{
    connection = new SqlConnection(connectionString);

    ...

    connection.Close();
}
finally
{
    connection.Dispose();
}

Answer 3

As others already said, there is nothing wrong with what you're doing right now. ADO.NET objects are meant to be used and disposed of. As a rule of thumb you should create them as late as possible and dispose of them as soon as possible .

With that being said, I understand what you're trying to do here and I do have a few ideas you might be interested in for making your life easier while keeping good programming practices.

If you want to make the code more concise you can chain using statements:

using (var cn = new SqlConnection(yourConnectionString))
using (var cmd = new SqlCommand(yourQuery, cn))
{
    // do stuff
}

The IDE will not try to indent the second block, making it easier on you to read.

You can also create an abstraction layer for your procedure:

public static class Procedures
{
    public static void RegisterUser() // add whatever parameters you need
    {
        using (var cn = new SqlConnection(yourConnectionString))
        using (var cmd = new SqlCommand(yourQuery, cn))
        {
            // do stuff
        }
    }
}

From then on you can execute your procedure simply by calling:

Procedures.RegisterUser();

Another alternative is to introduce a factory pattern to get your objects. This alone won't reduce their number but it might help in getting them all set up already (ie correct connection string).

You also can be creative and combine the two patterns. A custom class implementing IDisposable can take care of creating the necessary ADO objects, open the connection, execute your query, close the connection and dispose of any objects that needs disposal when it is itself disposed of.

Take your pick.