Merge remote-tracking branch 'origin/develop' into develop

EvilBeaver · EvilBeaver · commit 07f6cec42eec · 2025-12-14T22:11:49.000+03:00
# Conflicts:
#	src/OneScript.StandardLibrary/Http/HttpResponseBody.cs
diff --git a/.github/workflows/sonar.yml b/.github/workflows/sonar.yml
@@ -19,14 +19,14 @@ jobs:
         with:
           fetch-depth: 0  # Shallow clones should be disabled for a better relevancy of analysis
       - name: Cache SonarQube packages
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: ~\sonar\cache
           key: ${{ runner.os }}-sonar
           restore-keys: ${{ runner.os }}-sonar
       - name: Cache SonarQube scanner
         id: cache-sonar-scanner
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         with:
           path: .\.sonar\scanner
           key: ${{ runner.os }}-sonar-scanner
diff --git a/src/OneScript.StandardLibrary/Http/HttpResponseBody.cs b/src/OneScript.StandardLibrary/Http/HttpResponseBody.cs
@@ -1,7 +1,7 @@
 /*----------------------------------------------------------
-This Source Code Form is subject to the terms of the
-Mozilla Public License, v.2.0. If a copy of the MPL
-was not distributed with this file, You can obtain one
+This Source Code Form is subject to the terms of the 
+Mozilla Public License, v.2.0. If a copy of the MPL 
+was not distributed with this file, You can obtain one 
 at http://mozilla.org/MPL/2.0/.
 ----------------------------------------------------------*/
 
@@ -25,7 +25,8 @@ class HttpResponseBody : IDisposable
 
         private readonly bool _autoDecompress;
         private long _contentSize = 0;
-        private Stream _rawStream;
+        private readonly Stream _rawStream;
+        private bool _inMemoryResponseInited;
 
         public HttpResponseBody(HttpWebResponse response, string dumpToFile)
         {
@@ -35,47 +36,59 @@ public HttpResponseBody(HttpWebResponse response, string dumpToFile)
                 return;
             }
 
+            _inMemoryResponseInited = false;
             _rawStream = response.GetResponseStream();
             _autoDecompress = string.Equals(response.ContentEncoding, "gzip", StringComparison.OrdinalIgnoreCase);
             _contentSize = _autoDecompress ? -1 : response.ContentLength;
 
             if (!String.IsNullOrEmpty(dumpToFile))
             {
-                InitFileBackedResponse(response, dumpToFile);
+                InitFileBackedResponse(dumpToFile);
             }
-            else if (_autoDecompress)
+            else if(_autoDecompress)
             {
-                InitInMemoryResponse(response);
+                InitInMemoryResponse();
             }
         }
 
-        private void InitInMemoryResponse(HttpWebResponse response)
+        private void InitInMemoryResponse()
         {
-            if (_contentSize > INMEMORY_BODY_LIMIT)
+            if(_contentSize > INMEMORY_BODY_LIMIT)
             {
                 var filename = Path.GetTempFileName();
                 _backFileIsTemp = true;
-                InitFileBackedResponse(response, filename);
+                InitFileBackedResponse(filename);
             }
             else
             {
-                if (_contentSize == UNDEFINED_LENGTH)
+                if(_contentSize == UNDEFINED_LENGTH)
                 {
-                    ReadToStream(response);
+                    ReadToStream();
                 }
                 else
                 {
-                    ReadToArray(response);
+                    ReadToArray();
                 }
             }
+            _inMemoryResponseInited = true;
         }
 
         public bool AutoDecompress => _autoDecompress;
 
         public long ContentSize => _contentSize < 0 ? 0 : _contentSize;
 
-        public Stream OpenReadStream()
+        public Stream OpenReadStream(bool raw = false)
         {
+            if (raw)
+            {
+                return GetResponseStream();
+            }
+
+            if (!_inMemoryResponseInited)
+            {
+                InitInMemoryResponse();
+            }
+
             if (_backingFileName != null)
             {
                 return new FileStream(_backingFileName, FileMode.Open, FileAccess.Read);
@@ -85,20 +98,20 @@ public Stream OpenReadStream()
                 return new MemoryStream(_inMemBody);
             }
             else
-                return _rawStream;
+                throw new InvalidOperationException("No response body");
         }
 
-        private Stream GetResponseStream(HttpWebResponse response)
+        private Stream GetResponseStream()
         {
             if (_autoDecompress)
-                return new GZipStream(response.GetResponseStream(), CompressionMode.Decompress);
-            return response.GetResponseStream();
+                return new GZipStream(_rawStream, CompressionMode.Decompress);
+            return _rawStream;
         }
 
-        private void ReadToStream(HttpWebResponse response)
+        private void ReadToStream()
         {
-            using (var responseStream = GetResponseStream(response))
-            using (var ms = new MemoryStream())
+            using (var responseStream = GetResponseStream())
+            using(var ms = new MemoryStream())
             {
                 bool memStreamIsAlive = true;
 
@@ -114,7 +127,7 @@ private void ReadToStream(HttpWebResponse response)
 
                     readTotal += bytesRead;
 
-                    if (readTotal > INMEMORY_BODY_LIMIT)
+                    if(readTotal > INMEMORY_BODY_LIMIT)
                     {
                         var filename = Path.GetTempFileName();
                         _backFileIsTemp = true;
@@ -130,10 +143,11 @@ private void ReadToStream(HttpWebResponse response)
                         }
 
                         break;
+
                     }
                 }
 
-                if (memStreamIsAlive)
+                if(memStreamIsAlive)
                 {
                     _inMemBody = new byte[ms.Length];
                     ms.Position = 0;
@@ -145,11 +159,11 @@ private void ReadToStream(HttpWebResponse response)
             }
         }
 
-        private void ReadToArray(HttpWebResponse response)
+        private void ReadToArray()
         {
             System.Diagnostics.Debug.Assert(_contentSize <= INMEMORY_BODY_LIMIT);
 
-            using var stream = GetResponseStream(response);
+            using var stream = GetResponseStream();
             var mustRead = (int)_contentSize;
             _inMemBody = new byte[mustRead];
             int offset = 0;
@@ -167,12 +181,12 @@ private void ReadToArray(HttpWebResponse response)
             }
         }
 
-        private void InitFileBackedResponse(HttpWebResponse response, string backingFileName)
+        private void InitFileBackedResponse(string backingFileName)
         {
             _backingFileName = backingFileName;
-            using (var responseStream = GetResponseStream(response))
+            using (var responseStream = GetResponseStream())
             {
-                using (var file = new FileStream(backingFileName, FileMode.Create))
+                using(var file = new FileStream(backingFileName, FileMode.Create))
                 {
                     StreamToStreamCopy(responseStream, file);
                 }
@@ -205,9 +219,9 @@ private void Dispose(bool manualDispose)
 
         private void KillTemporaryFile()
         {
-            if (_backFileIsTemp && _backingFileName != null)
+            if(_backFileIsTemp && _backingFileName != null)
             {
-                if (File.Exists(_backingFileName))
+                if(File.Exists(_backingFileName))
                 {
                     try
                     {
@@ -231,4 +245,4 @@ public void Dispose()
             Dispose(false);
         }
     }
-}
+}
diff --git a/src/OneScript.StandardLibrary/Http/HttpResponseContext.cs b/src/OneScript.StandardLibrary/Http/HttpResponseContext.cs
@@ -131,14 +131,14 @@ public IValue GetBodyAsBinaryData()
         /// <summary>
         /// Интерпретировать ответ, как Поток
         /// </summary>
+        /// <param name="rawStream">Булево. Будет получен сырой поток без дополнительной обработки. По умолчанию Ложь</param>
         /// <returns>Поток</returns>
         [ContextMethod("ПолучитьТелоКакПоток", "GetBodyAsStream")]
-        public IValue GetBodyAsStream()
+        public IValue GetBodyAsStream(bool rawStream = false)
         {
             if (_body == null)
                 return ValueFactory.Create();
-
-            return new GenericStream(_body.OpenReadStream(), true);
+            return new GenericStream(_body.OpenReadStream(rawStream), true);
         }
 
         /// <summary>
diff --git a/tests/global-funcs.os b/tests/global-funcs.os
@@ -6,12 +6,18 @@
 ///////////////////////////////////////////////////////////////////////
 
 Перем юТест;
+Перем мАдресРесурса; // URL ресурса (хоста) для тестирования запросов
 
 ////////////////////////////////////////////////////////////////////
 // Программный интерфейс
 
 Функция ПолучитьСписокТестов(ЮнитТестирование) Экспорт
 	
+	Если мАдресРесурса = Неопределено Тогда
+		ПодключитьСценарий("./tests/http.os", "http_тест");
+		мАдресРесурса = Новый http_тест().ВыбратьДоступныйХост();
+	КонецЕсли;
+
 	юТест = ЮнитТестирование;
 	
 	ВсеТесты = Новый Массив;
@@ -652,7 +658,7 @@
 
 	Приемник = ПолучитьИмяВременногоФайла();
 
-	КопироватьФайл("http://httpbin.org/image", Приемник);
+	КопироватьФайл(мАдресРесурса + "/image", Приемник);
 
 	Попытка
 		ДД = Новый ДвоичныеДанные(Приемник);
@@ -670,7 +676,7 @@
 
 	Приемник = ПолучитьИмяВременногоФайла();
 
-	КопироватьФайл("https://httpbin.org/image", Приемник);
+	КопироватьФайл(мАдресРесурса + "/image", Приемник);
 
 	Попытка
 		ДД = Новый ДвоичныеДанные(Приемник);
@@ -689,7 +695,7 @@
 	Приемник = ПолучитьИмяВременногоФайла();
 
 	Попытка
-		ПереместитьФайл("http://httpbin.org/image", Приемник);
+		ПереместитьФайл(мАдресРесурса + "/image", Приемник);
 	Исключение
 		//Отвалится по 405, значит delete метод отрабатывает
 		Описание = ОписаниеОшибки();
diff --git a/tests/http.os b/tests/http.os
@@ -39,6 +39,10 @@
 	ВсеТесты.Добавить("ТестДолженПроверитьЧтоМетодыБезТелаПриУстановленномТелеУспешноВыполняются");
 	ВсеТесты.Добавить("ТестДолженПроверитьЧтоРаботаетПолучениеДвоичныхДанныхИзОтвета");
 
+	ВсеТесты.Добавить("ТестДолженПроверитьЧтоТелоМожноПолучитьНесколькоРаз");
+	ВсеТесты.Добавить("ТестДолженПроверитьПолучениеТелаПослеЗакрытогоПотока");
+	ВсеТесты.Добавить("ТестДолженПроверитьНедоступностьЧистогоПотокаПослеПолученияТела");
+
 	ВсеТесты.Добавить("ТестДолженПроверитьПолучениеStreamEvent");
 
 	Возврат ВсеТесты;
@@ -390,6 +394,72 @@
 	юТест.ПроверитьТип(ДД, Тип("ДвоичныеДанные"));
 	юТест.ПроверитьРавенство(ДД.Размер(), 10);
 
+КонецПроцедуры
+
+ Процедура ТестДолженПроверитьЧтоТелоМожноПолучитьНесколькоРаз() Экспорт
+
+	Запрос = Новый HttpЗапрос("/get?p1=v1&p2=v2");
+
+	Соединение = Новый HttpСоединение(мАдресРесурса);
+	Ответ = Соединение.Получить(Запрос);
+
+	юТест.ПроверитьРавенство(200, Ответ.КодСостояния);
+
+	Ответ.ПолучитьТелоКакПоток();
+
+	юТест.ПроверитьРавенство(Ответ.ПолучитьТелоКакПоток().ДоступноЧтение, Истина);
+
+	юТест.ПроверитьРавенство(ТипЗнч(Ответ.ПолучитьТелоКакДвоичныеДанные()), Тип("ДвоичныеДанные"));
+	юТест.ПроверитьВхождение(Ответ.ПолучитьТелоКакСтроку(), """p1"": ""v1""");
+	юТест.ПроверитьВхождение(Ответ.ПолучитьТелоКакСтроку(), """p2"": ""v2""");
+
+	юТест.ПроверитьРавенство(ТипЗнч(Ответ.ПолучитьТелоКакДвоичныеДанные()), Тип("ДвоичныеДанные"));
+
+	// Оригинальный поток уже вычитан вернется поддельный
+	юТест.ПроверитьРавенство(Ответ.ПолучитьТелоКакПоток().ДоступноЧтение, Истина);
+
+КонецПроцедуры
+
+Процедура ТестДолженПроверитьПолучениеТелаПослеЗакрытогоПотока() Экспорт
+
+	Запрос = Новый HttpЗапрос("/get?p1=v1&p2=v2");
+
+	Соединение = Новый HttpСоединение(мАдресРесурса);
+	Ответ = Соединение.Получить(Запрос);
+
+	юТест.ПроверитьРавенство(200, Ответ.КодСостояния);
+
+	Поток = Ответ.ПолучитьТелоКакПоток();
+	Поток.Закрыть();
+
+	юТест.ПроверитьВхождение(Ответ.ПолучитьТелоКакСтроку(), """p2"": ""v2""");
+
+КонецПроцедуры
+
+Процедура ТестДолженПроверитьНедоступностьЧистогоПотокаПослеПолученияТела() Экспорт
+
+	Запрос = Новый HttpЗапрос("/get?p1=v1&p2=v2");
+
+	Соединение = Новый HttpСоединение(мАдресРесурса);
+	Ответ = Соединение.Получить(Запрос);
+
+	юТест.ПроверитьРавенство(200, Ответ.КодСостояния);
+
+	юТест.ПроверитьВхождение(Ответ.ПолучитьТелоКакСтроку(), """p2"": ""v2""");
+
+	// чистый поток не доступен для чтения
+	Поток = Ответ.ПолучитьТелоКакПоток(Истина);
+	юТест.ПроверитьРавенство(Поток.ДоступноЧтение, Ложь);
+
+	// оберточный нормальный
+	Поток = Ответ.ПолучитьТелоКакПоток();
+	юТест.ПроверитьРавенство(Поток.ДоступноЧтение, Истина);
+	ЧтениеДанных = Новый ЧтениеДанных(Поток);
+	юТест.ПроверитьВхождение(
+			ПолучитьСтрокуИзДвоичныхДанных(ЧтениеДанных.Прочитать().ПолучитьДвоичныеДанные()),
+			"""p2"": ""v2"""
+	);
+
 КонецПроцедуры
 
 Процедура ТестДолженПроверитьПолучениеStreamEvent() Экспорт
@@ -411,7 +481,7 @@
 	Прошло = ТекущаяУниверсальнаяДатаВМиллисекундах() - Старт;
 	ютест.ПроверитьМеньше(Прошло, 600);
 
-	ТелоПоток = Ответ.ПолучитьТелоКакПоток();
+	ТелоПоток = Ответ.ПолучитьТелоКакПоток(Истина);
 	юТест.ПроверитьТип(ТелоПоток, Тип("Поток"));
 
 	ЧтениеДанных = Новый ЧтениеДанных(ТелоПоток);
@@ -492,7 +562,7 @@
 
 КонецФункции
 
-Функция ВыбратьДоступныйХост()
+Функция ВыбратьДоступныйХост() Экспорт
 
 	// Если задана переменная окружения, используем ее при наличии значения
 	ЗначениеИзОкружения = ПолучитьПеременнуюСреды("OS_HTTP_TEST_HOST");
@@ -508,6 +578,7 @@
 	// Пробуем типовые варианты httpbin
 	Кандидаты = Новый Массив;
 	Кандидаты.Добавить("http://127.0.0.1:8085");
+	Кандидаты.Добавить("https://connectorhttp.ru");
 	Кандидаты.Добавить("https://httpbin.org");
 	Кандидаты.Добавить("https://httpbingo.org");
 

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`/*----------------------------------------------------------`
`2`		`-This Source Code Form is subject to the terms of the`
`3`		`-Mozilla Public License, v.2.0. If a copy of the MPL`
`4`		`-was not distributed with this file, You can obtain one`
	`2`	`+This Source Code Form is subject to the terms of the`
	`3`	`+Mozilla Public License, v.2.0. If a copy of the MPL`
	`4`	`+was not distributed with this file, You can obtain one`
`5`	`5`	`at http://mozilla.org/MPL/2.0/.`
`6`	`6`	`----------------------------------------------------------*/`
`7`	`7`
`@@ -25,7 +25,8 @@ class HttpResponseBody : IDisposable`
`25`	`25`
`26`	`26`	`private readonly bool _autoDecompress;`
`27`	`27`	`private long _contentSize = 0;`
`28`		`- private Stream _rawStream;`
	`28`	`+ private readonly Stream _rawStream;`
	`29`	`+ private bool _inMemoryResponseInited;`
`29`	`30`
`30`	`31`	`public HttpResponseBody(HttpWebResponse response, string dumpToFile)`
`31`	`32`	`{`
`@@ -35,47 +36,59 @@ public HttpResponseBody(HttpWebResponse response, string dumpToFile)`
`35`	`36`	`return;`
`36`	`37`	`}`
`37`	`38`
	`39`	`+ _inMemoryResponseInited = false;`
`38`	`40`	`_rawStream = response.GetResponseStream();`
`39`	`41`	`_autoDecompress = string.Equals(response.ContentEncoding, "gzip", StringComparison.OrdinalIgnoreCase);`
`40`	`42`	`_contentSize = _autoDecompress ? -1 : response.ContentLength;`
`41`	`43`
`42`	`44`	`if (!String.IsNullOrEmpty(dumpToFile))`
`43`	`45`	`{`
`44`		`- InitFileBackedResponse(response, dumpToFile);`
	`46`	`+ InitFileBackedResponse(dumpToFile);`
`45`	`47`	`}`
`46`		`- else if (_autoDecompress)`
	`48`	`+ else if(_autoDecompress)`
`47`	`49`	`{`
`48`		`- InitInMemoryResponse(response);`
	`50`	`+ InitInMemoryResponse();`
`49`	`51`	`}`
`50`	`52`	`}`
`51`	`53`
`52`		`- private void InitInMemoryResponse(HttpWebResponse response)`
	`54`	`+ private void InitInMemoryResponse()`
`53`	`55`	`{`
`54`		`- if (_contentSize > INMEMORY_BODY_LIMIT)`
	`56`	`+ if(_contentSize > INMEMORY_BODY_LIMIT)`
`55`	`57`	`{`
`56`	`58`	`var filename = Path.GetTempFileName();`
`57`	`59`	`_backFileIsTemp = true;`
`58`		`- InitFileBackedResponse(response, filename);`
	`60`	`+ InitFileBackedResponse(filename);`
`59`	`61`	`}`
`60`	`62`	`else`
`61`	`63`	`{`
`62`		`- if (_contentSize == UNDEFINED_LENGTH)`
	`64`	`+ if(_contentSize == UNDEFINED_LENGTH)`
`63`	`65`	`{`
`64`		`- ReadToStream(response);`
	`66`	`+ ReadToStream();`
`65`	`67`	`}`
`66`	`68`	`else`
`67`	`69`	`{`
`68`		`- ReadToArray(response);`
	`70`	`+ ReadToArray();`
`69`	`71`	`}`
`70`	`72`	`}`
	`73`	`+ _inMemoryResponseInited = true;`
`71`	`74`	`}`
`72`	`75`
`73`	`76`	`public bool AutoDecompress => _autoDecompress;`
`74`	`77`
`75`	`78`	`public long ContentSize => _contentSize < 0 ? 0 : _contentSize;`
`76`	`79`
`77`		`- public Stream OpenReadStream()`
	`80`	`+ public Stream OpenReadStream(bool raw = false)`
`78`	`81`	`{`
	`82`	`+ if (raw)`
	`83`	`+ {`
	`84`	`+ return GetResponseStream();`
	`85`	`+ }`
	`86`	`+`
	`87`	`+ if (!_inMemoryResponseInited)`
	`88`	`+ {`
	`89`	`+ InitInMemoryResponse();`
	`90`	`+ }`
	`91`	`+`
`79`	`92`	`if (_backingFileName != null)`
`80`	`93`	`{`
`81`	`94`	`return new FileStream(_backingFileName, FileMode.Open, FileAccess.Read);`
`@@ -85,20 +98,20 @@ public Stream OpenReadStream()`
`85`	`98`	`return new MemoryStream(_inMemBody);`
`86`	`99`	`}`
`87`	`100`	`else`
`88`		`- return _rawStream;`
	`101`	`+ throw new InvalidOperationException("No response body");`
`89`	`102`	`}`
`90`	`103`
`91`		`- private Stream GetResponseStream(HttpWebResponse response)`
	`104`	`+ private Stream GetResponseStream()`
`92`	`105`	`{`
`93`	`106`	`if (_autoDecompress)`
`94`		`- return new GZipStream(response.GetResponseStream(), CompressionMode.Decompress);`
`95`		`- return response.GetResponseStream();`
	`107`	`+ return new GZipStream(_rawStream, CompressionMode.Decompress);`
	`108`	`+ return _rawStream;`
`96`	`109`	`}`
`97`	`110`
`98`		`- private void ReadToStream(HttpWebResponse response)`
	`111`	`+ private void ReadToStream()`
`99`	`112`	`{`
`100`		`- using (var responseStream = GetResponseStream(response))`
`101`		`- using (var ms = new MemoryStream())`
	`113`	`+ using (var responseStream = GetResponseStream())`
	`114`	`+ using(var ms = new MemoryStream())`
`102`	`115`	`{`
`103`	`116`	`bool memStreamIsAlive = true;`
`104`	`117`
`@@ -114,7 +127,7 @@ private void ReadToStream(HttpWebResponse response)`
`114`	`127`
`115`	`128`	`readTotal += bytesRead;`
`116`	`129`
`117`		`- if (readTotal > INMEMORY_BODY_LIMIT)`
	`130`	`+ if(readTotal > INMEMORY_BODY_LIMIT)`
`118`	`131`	`{`
`119`	`132`	`var filename = Path.GetTempFileName();`
`120`	`133`	`_backFileIsTemp = true;`
`@@ -130,10 +143,11 @@ private void ReadToStream(HttpWebResponse response)`
`130`	`143`	`}`
`131`	`144`
`132`	`145`	`break;`
	`146`	`+`
`133`	`147`	`}`
`134`	`148`	`}`
`135`	`149`
`136`		`- if (memStreamIsAlive)`
	`150`	`+ if(memStreamIsAlive)`
`137`	`151`	`{`
`138`	`152`	`_inMemBody = new byte[ms.Length];`
`139`	`153`	`ms.Position = 0;`
`@@ -145,11 +159,11 @@ private void ReadToStream(HttpWebResponse response)`
`145`	`159`	`}`
`146`	`160`	`}`
`147`	`161`
`148`		`- private void ReadToArray(HttpWebResponse response)`
	`162`	`+ private void ReadToArray()`
`149`	`163`	`{`
`150`	`164`	`System.Diagnostics.Debug.Assert(_contentSize <= INMEMORY_BODY_LIMIT);`
`151`	`165`
`152`		`- using var stream = GetResponseStream(response);`
	`166`	`+ using var stream = GetResponseStream();`
`153`	`167`	`var mustRead = (int)_contentSize;`
`154`	`168`	`_inMemBody = new byte[mustRead];`
`155`	`169`	`int offset = 0;`
`@@ -167,12 +181,12 @@ private void ReadToArray(HttpWebResponse response)`
`167`	`181`	`}`
`168`	`182`	`}`
`169`	`183`
`170`		`- private void InitFileBackedResponse(HttpWebResponse response, string backingFileName)`
	`184`	`+ private void InitFileBackedResponse(string backingFileName)`
`171`	`185`	`{`
`172`	`186`	`_backingFileName = backingFileName;`
`173`		`- using (var responseStream = GetResponseStream(response))`
	`187`	`+ using (var responseStream = GetResponseStream())`
`174`	`188`	`{`
`175`		`- using (var file = new FileStream(backingFileName, FileMode.Create))`
	`189`	`+ using(var file = new FileStream(backingFileName, FileMode.Create))`
`176`	`190`	`{`
`177`	`191`	`StreamToStreamCopy(responseStream, file);`
`178`	`192`	`}`
`@@ -205,9 +219,9 @@ private void Dispose(bool manualDispose)`
`205`	`219`
`206`	`220`	`private void KillTemporaryFile()`
`207`	`221`	`{`
`208`		`- if (_backFileIsTemp && _backingFileName != null)`
	`222`	`+ if(_backFileIsTemp && _backingFileName != null)`
`209`	`223`	`{`
`210`		`- if (File.Exists(_backingFileName))`
	`224`	`+ if(File.Exists(_backingFileName))`
`211`	`225`	`{`
`212`	`226`	`try`
`213`	`227`	`{`
`@@ -231,4 +245,4 @@ public void Dispose()`
`231`	`245`	`Dispose(false);`
`232`	`246`	`}`
`233`	`247`	`}`
`234`		`-}`
	`248`	`+}`