Форум программистов и сисадминов Киберфорум - Блоги - Exerion

IDisposable - правильное использование

Exerion — Tue, 16 Jun 2015 12:53:18 GMT

Довольно долгое время я мучился в попытках познать тонкости интерфейса IDisposable и метода Dispose, особенно вводило меня в ступор наличие перегрузки этого метода с булевым аргументом. Со временем те или иные аспекты становились яснее, но полной картины у меня в голове не было до тех пор, пока я не наткнулся на ответ/статью по данной теме на stackoverflow.com, мой вольный перевод которой вы можете увидеть ниже.

Смысл Dispose - освободить неуправляемые ресурсы (прим.переводчика - в качестве неуправляемых ресурсов можно привести соединения с базами данных, сокеты, дескрипторы окон и т.д). Освобождение неуправляемых ресурсов должно быть произведено в определённый момент, иначе они не будут освобождены вообще. Сборщик мусора (garbage collector, GC) не знает, как вызывать метод DeleteHandle() на переменной типа IntPtr, а также не знает, нужно ли вообще его вызывать.

Прим.: Что такое неуправляемые ресурсы? Если вы пользуетесь чем-либо внутри Microsoft .NET Framework - это управляемые ресурсы. Если вы решили полазать по MSDN самостоятельно, это неуправляемые ресурсы. Всё, что используется, когда вы вызываете P/Invoke чтобы выбраться за границы уютненького мира возможностей .NET Framework - неуправляемые ресурсы, и вы теперь ответственны за их очистку.

Создаваемый вами объект должен иметь метод, который мог бы быть вызван внешним миром для очистки неуправляемых ресурсов. Существует даже стандартизированное название для этого метода:

C#
1
public void Dispose()

Мало того, даже был создан интерфейс - IDisposable - который имеет всего один этот метод:

C#
1
2
3
4
public interface IDisposable
{
   void Dispose()
}

Итак, в своём объекте вы реализуете интерфейс IDisposable и таким образом даёте обещание, что вы написали этот единственный метод для очистки неуправляемых ресурсов:

C#
1
2
3
4
public void Dispose()
{
   Win32.DestroyHandle(this.gdiCursorBitmapStreamFileHandle);
}

Вот и всё. Однако можно сделать лучше.
________________________________________ ________________________________________ ___

Что, если ваш объект выделил 250Мб System.Drawing.Bitmap (т.е. управляемый .NET Bitmap класс) в качестве некоего кадрового буфера? Безусловно, это управляемый объект, и сборщик мусора освободит память, занимаемую им. Но действительно ли вы хотите оставить кусок памяти в 250Мб просто лежать где-то, дожидаясь когда сборщик мусора удосужится добраться и освободить его? А что, если там же есть открытое соединение с базой данных? Однозначно мы не хотели бы оставлять это соединение открытым, ожидая пока GC финализирует объект.

Поэтому мы:

разберёмся с неуправляемыми ресурсами (потому что мы должны), и
разберёмся с управляемыми ресурсами (потому что мы хотим быть полезными) :)

Итак, давайте обновим наш Dispose() метод, чтобы избавиться от управляемых ресурсов:

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void Dispose()
{
   //Free unmanaged resources
   Win32.DestroyHandle(this.gdiCursorBitmapStreamFileHandle);
 
   //Free managed resources too
   if (this.databaseConnection != null)
   {
      this.databaseConnection.Dispose();
      this.databaseConnection = null;
   }
   if (this.frameBufferImage != null)
   {
      this.frameBufferImage.Dispose();
      this.frameBufferImage = null;
   }
}

Всё это здорово, однако можно сделать лучше!
________________________________________ ________________________________________ ___

А что, если человек забыл вызывать Dispose() на вашем объекте? Произойдёт утечка неуправляемых ресурсов!

Прим.: Утечки управляемых ресурсов не будет, потому что сборщик мусора рано или поздно запустится в фоновом потоке и очистит память, занимаемую любыми неиспользуемыми объектами. Сюда входит ваш объект и любые используемые вами управляемые объекты (те же Bitmap и DbConnection).

Если человек забыл вызвать Dispose(), мы всё ещё можем спасти ситуацию. Мы можем вызывать этот метод, когда сборщик мусора доберётся до объекта, чтобы освободить (финализировать) его.

Прим.: Сборщик мусора рано или поздно освобождает все управляемые объекты путём вызова метода Finalize на объекте. GC ничего не знает о вашем Dispose методе и ему нет до него никакого дела. Это всего лишь название, которое мы выбрали для метода, вызываемого нами для очистки неуправляемых ресурсов.

Уничтожение объекта сборщиком мусора - идеальный момент для освобождения этих надоедливых неуправляемых ресурсов. Мы сделаем это, переопределив метод Finalize().

Прим.: В C# вы не переопределяете метод Finalize() явно. Вместо этого вы пишете метод, который похож на C++ деструктор, а компилятор принимает его как вашу реализацию метода Finalize():

C#
1
2
3
4
5
~MyObject()
{
    //мы были финализированы (т.е. уничтожены), вызовите Dispose() на случай, если пользователь забыл сделать это
    Dispose(); //<--ПРЕДУПРЕЖДЕНИЕ! Тут кроется ошибка! Читайте ниже.
}

Однако в этом коде есть ошибка. Сборщик мусора работает в фоновом потоке, и вы не знаете последовательность, в которой два объекта будут уничтожены. Вполне возможно, что в коде вашего Dispose() метода управляемый объект, от которого вы хотите избавиться, больше не существует:

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void Dispose()
{
   //Освободить неуправляемые ресурсы
   Win32.DestroyHandle(this.gdiCursorBitmapStreamFileHandle);
 
   //Освободить также и управляемые ресурсы
   if (this.databaseConnection != null)
   {
      this.databaseConnection.Dispose(); <-- ошибка, GC уже уничтожил это
      this.databaseConnection = null;
   }
   if (this.frameBufferImage != null)
   {
      this.frameBufferImage.Dispose(); <-- ошибка, GC уже уничтожил это
      this.frameBufferImage = null;
   }
}

Что вам нужно, так это способ, с помощью которого метод Finalize() может сказать методу Dispose() не трогать управляемые ресурсы (потому что их может уже и не быть) во время освобождения неуправляемых.
Стандартный паттерн для этого - из обоих методов Finalize() и Dispose() вызывать третий(!) метод, куда вы передадите Boolean значение, означающее, что вы вызываете его из Dispose() (в противоположность Finalize()), в том смысле, что можно безопасно освобождать управляемые ресурсы.

Этот внутренний (internal) метод мог бы иметь произвольное название вроде "CoreDispose" или "MyInternalDispose", но традиционно его называют Dispose(Boolean) (прим.переводчика - откуда и растёт непонимание):

C#
1
protected void Dispose(Boolean disposing)

Но более полезное для понимания имя параметра могло быть таким:

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
protected void Dispose(Boolean itIsSafeToAlsoFreeManagedObjects)
{
   //Освободить неуправляемые ресурсы
   Win32.DestroyHandle(this.gdiCursorBitmapStreamFileHandle);
 
   //Освободить также управляемые ресурсы, но только если вызов был из Dispose
   //(если вызов был из Finalize, эти объекты могут уже не существовать)
   if (itIsSafeToAlsoFreeManagedObjects)  
   {    
      if (this.databaseConnection != null)
      {
         this.databaseConnection.Dispose();
         this.databaseConnection = null;
      }
      if (this.frameBufferImage != null)
      {
         this.frameBufferImage.Dispose();
         this.frameBufferImage = null;
      }
   }
}

Теперь вы меняете свою реализацию метода IDisposable.Dispose() на:

C#
1
2
3
4
public void Dispose()
{
   Dispose(true); //Я вызываю тебя из Dispose(), это безопасно
}

...и реализацию финализатора:

C#
1
2
3
4
~MyObject()
{
   Dispose(false); //Я *НЕ* вызываю тебя из Dispose(), это *НЕ* безопасно
}

Прим.: если ваш объект наследуется от объекта, который реализует Dispose, не забудьте вызывать Dispose базового класса, когда вы переопределяете Dispose:

C#
1
2
3
4
5
6
7
8
9
10
11
public Dispose()
{
    try
    {
        Dispose(true); //true: безопасно для освобождения управляемых ресурсов
    }
    finally
    {
        base.Dispose();
    }
}

Всё это здорово, однако можно сделать лучше!
________________________________________ ________________________________________ ___

Если пользователь вызывает Dispose() на вашем объекте, то всё будет очищено. Позднее, когда сборщик мусора доберётся до объекта и вызовет Finalize, он снова вызовет Dispose.

Не только это расточительно, но и если ваш объект имеет мусорные ссылки на объекты, которые вы уже очистили с прошлого вызова Dispose(), вы вызовете их очистку повторно!

Вы могли заметить в моём коде, что я был аккуратен и удалял ссылки на уже очищенные объекты, таким образом я не вызывал Dispose на "мусорных ссылках". Однако даже это не остановит этот неуловимый баг.

Когда пользователь вызывает Dispose(), дескриптор gdiCursorBitmapStreamFileHandle уничтожается. Позднее, когда отработает сборщик мусора, он попытается уничтожить тот же дескриптор опять.

C#
1
2
3
4
5
6
protected void Dispose(Boolean iAmBeingCalledFromDisposeAndNotFinalize)
{
   //Free unmanaged resources
   Win32.DestroyHandle(this.gdiCursorBitmapStreamFileHandle); <-- двойное уничтожение
   ...
}

Мы можем исправить это, указав сборщику мусора, что ему не нужно беспокоиться о финализации объекта - ресурсы уже очищены и работы больше нет. Это делается путём вызова GC.SuppressFinalize() в методе Dispose():

C#
1
2
3
4
5
public void Dispose()
{
   Dispose(true); //Я вызываю тебя из Dispose(), это безопасно
   GC.SuppressFinalize(this); //Эй, GC. Больше не беспокойся о вызове Finalize
}

Теперь, когда пользователь вызывает Dispose(), мы:

очистили неуправляемые ресурсы
очистили управляемые ресурсы

Сборщику мусора нет смысла запускать финализатор - мы обо всём уже позаботились.

Текст оригинала на английском: stackoverflow

Алгоритм генерирования поля для игры "Судоку"

Exerion — Sat, 27 Apr 2013 11:34:32 GMT

Сообщение от Exerion

Всё не так просто, как два вложенных друг в друга цикла.
Делать было нечего, задачка показалась интересной, поэтому за два часа наговнокодил первое, что пришло в голову:

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
class Program
    {
        private static int[,] playField = new int[9, 9];
        private static List<int> wrongNumbers = new List<int>();
 
        static void Main(string[] args)
        {
            Console.WriteLine("Press ENTER to generate field");
            Console.ReadLine();
 
            InitField();
            bool result = false;
            result = GenerateField();
            while (!result)
            {
                Console.WriteLine("\n\nGeneration failed. Press ENTER to generate again.\n");
                Console.ReadLine();
                result = GenerateField();
            }
 
            Console.WriteLine("Generated field:\n\n");
            PrintField();
            Console.ReadLine();
        }
 
        private static void InitField()
        {
            for (int i = 0; i < 9; i++)
                for (int j = 0; j < 9; j++)
                    playField[i, j] = 0;
        }
 
        private static bool CheckLine(int line, int number)
        {
            for (int i = 0; i < 9; i++)
            {
                if (playField[line, i] == number)
                {
                    Console.WriteLine("[line-" + line + "] number " + number + "banned");
                    if(!wrongNumbers.Contains(number))
                        wrongNumbers.Add(number);
                    return true;
                }
            }
            Console.WriteLine("[line-" + line + "] number " + number + "passed!");
            return false;
        }
 
        private static bool CheckColumn(int col, int number)
        {
            for (int j = 0; j < 9; j++)
            {
                if (playField[j, col] == number)
                {
                    Console.WriteLine("[col-" + col + "] number " + number + "banned");
                    if (!wrongNumbers.Contains(number))
                        wrongNumbers.Add(number);
                    return true;
                }
            }
            Console.WriteLine("[col-" + col + "] number " + number + "passed!");
            return false;
        }
 
        private static bool CheckBlock(int line, int col, int number)
        {
            int blockLine = 0;
            int blockCol = 0;
 
            double blockNum = 0;
            blockNum = line + 1;
            blockNum = blockNum / 3;
            blockNum = Math.Ceiling(blockNum);
            blockLine = Convert.ToInt32(blockNum);
 
            blockNum = col + 1;
            blockNum = blockNum / 3;
            blockNum = Math.Ceiling(blockNum);
            blockCol = Convert.ToInt32(blockNum);
 
            if (blockLine == 0) blockLine = 1;
            if (blockCol == 0) blockCol = 1;
 
            for (int i = 0; i < 3; i++)
            {
                for (int j = 0; j < 3; j++)
                {
                    if (playField[i + (blockLine - 1) * 3, j + (blockCol - 1) * 3] == number)
                    {
                        Console.WriteLine("[block " + blockLine + "-" + blockCol + " (" + line + "+" + col + ")] banned number: " + number);
                        if (!wrongNumbers.Contains(number))
                            wrongNumbers.Add(number);
                        return true;
                    }
                }
            }
            return false;
        }
 
        private static bool GenerateField()
        {
            Random rnd = new Random();
            int number = 0;
            bool result = true;
 
            for (int i = 0; i < 9; i++)
            {
                for (int j = 0; j < 9; j++)
                {
                    number = rnd.Next(1, 10);
                    result = CheckLine(i, number);
                    while (result)
                    {
                        number = rnd.Next(1, 10);
                        if (wrongNumbers.Count > 8)
                        {
                            InitField();
                            wrongNumbers.Clear();
                            return false;
                        }
                        while (wrongNumbers.Contains(number))
                            number = rnd.Next(1, 10);
                        result = CheckLine(i, number);
                    }
 
                    result = CheckColumn(j, number);
                    if (result)
                    {
                        j--;
                        continue;
                    }
 
                    result = CheckBlock(i, j, number);
                    if (result)
                    {
                        j--;
                        continue;
                    }
 
                    playField[i, j] = number;
                    Console.WriteLine(number + "  [!] number " + number + " accepted!\nPlayField[" + i + "," + j + "] = " + number);
                    wrongNumbers.Clear();
                }
            }
            return true;
        }
 
        private static void PrintField()
        {
            // ─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼
            // ═ ║ ╔ ╗ ╚ ╝ ╠ ╣ ╦ ╩ ╬
            // ╒ ╓ ╕ ╖ ╘ ╙ ╛ ╜
            // ╞ ╟ ╡ ╢ ╤ ╥ ╧ ╨ ╪ ╫ 
 
            Console.WriteLine("╔══╤══╤══╦══╤══╤══╦══╤══╤══╗");
            for (int i = 0; i < 3; i++)
            {
                PrintLine(i * 3);
                Console.WriteLine("╟──┼──┼──╫──┼──┼──╫──┼──┼──╢");
                PrintLine(i * 3 + 1);
                Console.WriteLine("╟──┼──┼──╫──┼──┼──╫──┼──┼──╢");
                PrintLine(i * 3 + 2);
                if(i != 2)
                    Console.WriteLine("╠══╪══╪══╬══╪══╪══╬══╪══╪══╣");
            }
            Console.WriteLine("╚══╧══╧══╩══╧══╧══╩══╧══╧══╝");
        }
        private static void PrintLine(int line)
        {
            Console.WriteLine(
                "║" + playField[line, 0] + " │" + playField[line, 1] + " │" + playField[line, 2] + " ║" +
                playField[line, 3] + " │" + playField[line, 4] + " │" + playField[line, 5] + " ║" +
                playField[line, 6] + " │" + playField[line, 7] + " │" + playField[line, 8] + " ║");
        }
    }

Ранее мне казалось, что составить судоку - просто, бери да заполняй таблицу, следуя правилам. Как оказалось на примере программы - очень часто попадаешь в тупиковую ситуацию, когда таблица заполнена отсилы на половину, ни разу правила не нарушались, а новое число уже вписать нельзя.
Отсюда выходит, что генерация рабочего варианта судоку в зависимости от воли Великого Рандома может занять от нескольких секунд до десятка минут с учётом всех отброшенных "тупиковых" вариантов.

P.S. Строчку после сообщения о провале генерации можно закомментить, чтобы каждый раз не тыкать на энтер.

Схоронил, как говорится.