Блог

Я использую инструмент анализа кода Visual Studio, и одно из предупреждений, которое он мне выдает, гласит: «Не удаляйте объекты несколько раз: объект ‘conn’ может быть удален более одного раза в методе ‘CycleMessages.discriscan_reprint()’. Чтобы избежать создания системы.OjectDisposedEx вы не должны вызывать Dispose более одного раза для объекта. Строка:61

     private void discernScan_Reprint()
    {
        try
        {
            DataTable dt = new DataTable();

            SqlConnection conn = new SqlConnection("my constring");
            using (conn)
            {
                SqlCommand cmd = new SqlCommand("usp_myproc", conn);
                cmd.CommandType = CommandType.StoredProcedure;
                using(cmd)
                {
                    cmd.Parameters.Add(new SqlParameter("@param", param));
                    conn.Open();
                    SqlDataReader dr = cmd.ExecuteReader();
                    dt.Load(dr);
                    conn.Close();  // this is line 61
                }
            }

            switch(dt.Rows.Count)
            {
                default:
                    throw new Exception("message");
                case 1:
                    //do Stuff
                case 0:
                    //do stuff
                    break;
            }

        }
        catch (Exception ex) {throw;}
    }
  

Я не распоряжаюсь conn (явно через conn.Dispose();) , Я просто закрываю его и разрешаю использовать инкапсуляцию для удаления объекта conn — я знаю, что могу разрешить его закрытие с помощью удаления, но почему он говорит, что я удаляю его дважды? Во всяком случае, он должен предупредить меня о том, что «вам не нужно прерывать соединения с объектами, которые будут удалены» или что-то в этом роде. Я что-то упускаю?

Правки: из ссылки ref при закрытии…

Метод Close откатывает все ожидающие транзакции. Затем он освобождает соединение с пулом соединений или закрывает соединение, если объединение в пул отключено.

и

Если SqlConnection выходит за рамки, он не будет закрыт. Следовательно, вы должны явно закрыть соединение, вызвав Close или Dispose . Close и Dispose функционально эквивалентны. Если для значения пула соединений Pooling установлено значение true или yes, базовое соединение возвращается обратно в пул соединений. С другой стороны, если для пула установлено значение false или no, базовое соединение с сервером закрывается.

Я знаю, что функционально Close() — это то же самое, что и dispose , но, насколько я понимаю, это не буквально. Когда я закрываю объект, он не удаляется. Он либо закрывается, либо возвращается в пул соединений, удаляя (опять же, насколько я понимаю) внутренние вызовы методов close() — поэтому, несмотря на избыточность, я все еще озадачен тем, почему он явно говорит, что он уже удален, когда это не так.

Шаблон Dispose предполагает, что разработчики предоставляют синонимы для Dispose , которые имеют смысл в контексте объекта. Одним из таких синонимов SqlConnection является Close() :

Close и Dispose функционально эквивалентны.

Поскольку вы вызываете явно Close() , а Dispose() метод объекта вызывается при завершении using инструкции соединения, вы фактически вызываете Dispose() дважды.

Лучший подход заключается в том, чтобы просто позволить using блоку обрабатывать это за вас, поскольку это гарантирует, что Dispose() вызывается даже при возникновении исключения внутри using блока. Он также устанавливает переменную в значение null, чтобы ее можно было использовать как можно скорее.

Правки в ответ на вопросы @alykin

В документации говорится, что методы Close() и Dispose() функционально эквивалентны, но @alykin определил сценарий, в котором они фактически не выполняют одно и то же. Если я правильно читаю ее комментарий, это работает примерно так:

Работает следующее:

 SqlConnection conn = GetConnSomehow();
SqlCommand cmd = conn.CreateCommand(); 

// ...

conn.Open();

cmd.ExecuteSomething();

cmd.Close();

// ... time passes ...

conn.Open();
  

Следующее не:

 SqlConnection conn = GetConnSomehow();
SqlCommand cmd = conn.CreateCommand(); 

using ( conn ) {
    cmd.ExecuteSomething();
}

// ... time passes ...

// This won't compile, according to alykins.
conn.Open();
  

Это показывает, что объекты SqlConnection можно использовать повторно, по крайней мере, когда они были только Close() разделены.

Вероятно, причина, по которой второй пример с блоком using не компилируется, заключается в том, что компилятор знает, что conn было установлено значение null, когда using блок заканчивается, поэтому он знает, что вы не можете вызывать методы по нулевой ссылке на объект.

Я все еще не уверен, что это показывает, что a Dispose() на самом деле чем-то отличается от a Close() , поскольку несоответствие возникает из-за семантики обнуления блока using. Было бы целесообразно проверить, можно ли повторно открыть SqlConnection после того, как оно Dispose() ‘d, но не обнулено. Даже если бы это было так, я бы не стал полагаться на такое поведение, поскольку оно противоречит собственным рекомендациям Microsoft, изложенным в документации по шаблону Dispose.

Кроме того, я бы не стал использовать первый блок, который не использует блок using — в случае возникновения исключения соединение может быть потеряно или, по крайней мере, оставаться открытым в течение недетерминированного периода времени, пока GC не увидит, что произошла утечка объекта, и не вызовет его финализатор.

Я бы не стал полагаться на какую-либо разницу в поведении между Close() и Dispose() — я бы рекомендовал не пытаться повторно открыть ранее закрытый объект SqlConnection. Позвольте пул-программе фактически поддерживать соединение, даже если вы закроете или утилизируете переданный вам объект SqlConnection.

Примечание об использовании инструкций.

Рассмотрим следующий блок кода:

 IDisposable thing = GetThing();

using ( thing ) {
   thing.DoWork();
}
  

Этот блок кода точно идентичен этому блоку:

 IDisposable thing = GetThing();

try {
   thing.DoWork();
}
finally {
   thing.Dispose();
   thing = null;
}
  

И следующий блок, по мнению Microsoft, их документации и инструментов анализа, считается двумя распоряжениями:

 SqlConnection conn = GetConn();

using ( conn ) {
    DoWork(conn);
    conn.Close(); // code analysis tools count this as one Dispose().
} // implicit conn.Dispose() from the using block, so that's two.
  

Игнорируйте тот факт, что Close и Dispose точно не делают одно и то же. Они не хотят, чтобы вы полагались на это, и вы не должны этого делать, если поведение действительно исправлено.

Он информирует вас о том, что явное закрытие приводит к преждевременному расходованию ресурсов. Оператор using автоматически удалит его для вас.

Согласно MSDN:

Close и Dispose функционально эквивалентны.

Таким образом, вызов .Close() удаляет объект. Кроме того, поскольку объект находится в using блоке, компилятор также вызывает .Dispose() . Требуется только одно из двух. (И в данном случае рекомендуется последнее.)

По сути, вам просто нужно удалить вызов, Close() поскольку using блок обработает это за вас, когда он избавится от объекта:

 using (conn)
{
    SqlCommand cmd = new SqlCommand("usp_myproc", conn);
    cmd.CommandType = CommandType.StoredProcedure;
    using(cmd)
    {
        cmd.Parameters.Add(new SqlParameter("@param", param));
        conn.Open();
        System.Data.SqlClient.SqlDataReader dr = cmd.ExecuteReader();
        dt.Load(dr);
    }
}
  

close(); и dispose(); по сути, делайте то же самое, вот почему вы получаете это предупреждение. Проверьте эту ссылку для получения дополнительной информации.