Составляется с помощью операторов против отдельных с помощью операторов

Question

Во время рефакторинга кода я наткнулся на некоторые составные операторы (я говорю о 10-15).

using(X x=new X())
using(Y y=new Y())
using(Z z=new Z())
using(...)
{
    List<X> listX= x.GetParameterListByID(pID);
    List<Y> listY=y.GetParameterListByID(pID);
    ...
    ...
    //other (business) calls/code, like 20-30 lines, that don't need the using instances
}

Пример класса будет что-то вроде

public class X : IDisposable{
  public List<XParameterInfo> GetParameterListByID(int? pID){
      const string query="SELECT name,value FROM parameters WHERE id=@ID";
      //query code here
      return queryResult;
  }
}

И первое, о чем я подумал, было, зная, что using - это, в основном, try{} finally{ x.Dispose(); }, что используемые соединения будут оставаться открытыми / активными до тех пор, пока код в блоке использования не будет завершен, пока он необходим только для заполнить один список.

Это то, что я предполагаю, поправьте меня, если я ошибаюсь. Учитывая то, что я сказал, правильно, было бы лучше (производительность, но в основном хорошая практика) написать что-то вроде

List<X> listX;
List<Y> listY;
List<Z> listZ;
...
//for the example here I wrote out 3 but let's talk 10 or more

using(X x=new X())
{ 
   listX=x.GetParameterListByID(pID);
}
using(Y y=new Y())
{ 
   listY=y.GetParameterListByID(pID);
}
using(Z z=new Z())
{ 
   listZ=z.GetParameterListByID(pID);
} 
...
// other calls but now outside the using statements

или это ничтожно мало, кроме того факта, что сложенные using операторы убирают внешний вид вложенного кода?

Answer 1

В дополнение к тому, что сказал Тим, многие драйверы БД используют «пул соединений» для увеличения производительности соединений путем повторного использования старых. Поэтому, когда Dispose вызывается для соединений, они на самом деле не закрываются (за исключением случаев, когда выполняются определенные условия), но остаются бездействующими для последующих вызовов.

https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/connection-pooling

Answer 2

Почему вы не используете 1 соединение для всех запросов?

Я думаю, это было бы более элегантное решение.

void Main()
{
    List<X> listX;
    List<Y> listY;
    List<Z> listZ;
    using(SqlConnection conn = new SqlConnection())
    {
        conn.Open();
        listX=new X().GetParameterListByID(conn, pID);
        listY=new Y().GetParameterListByID(conn, pID);
        listZ=new Z().GetParameterListByID(conn, pID);
    }
}

Answer 3

было бы лучше (по производительности)

, который зависит от типов, которые используются в использовании. Вы не можете сделать общее заявление.

Производительность - не единственный фактор, открытые ресурсы могут блокировать другие процессы или вызывать проблемы с памятью. Но с другой стороны читаемость увеличивается с более компактной первой версией. Таким образом, вы должны решить, есть ли проблема вообще. Если нет, зачем? Затем выберите лучший читаемый и поддерживаемый код.

Но вы можете изменить свой код, используя метод для инкапсуляции значений:

// in class X:
public static List<X> GetParameterListByID(int pID)
{
    using(X x = new X())
    { 
       return x.GetParameterListByID(pID);
    }
} 
// and same in other classes

Теперь код не используется:

List<X> listX = X.GetParameterListByID(pID); // static method called
List<Y> listY = Y.GetParameterListByID(pID); // static method called